Merge pull request #5367 from NomicFoundation/refactor-parameter-fns

Refactor parameter fns

Author: schaable

v-next/core/src/internal/parameters.ts

@@ -1,3 +1,5 @@
+import { ParameterType } from "../types/common.js";
+
 /**
  * Names that can't be used as global- nor task-parameter names.
  */
@@ -16,3 +18,39 @@ const VALID_PARAM_NAME_CASING_REGEX = /^[a-z][a-zA-Z0-9]*$/;
 export function isValidParamNameCasing(name: string): boolean {
   return VALID_PARAM_NAME_CASING_REGEX.test(name);
 }
+
+/**
+ * Checks if a parameter value is valid for a given parameter type.
+ *
+ * This function uses a map of validators, where each validator is a function
+ * that checks if a value is valid for a specific parameter type.
+ * If the parameter type is variadic, the value is considered valid if it is an
+ * array and all its elements are valid for the parameter type. An empty array
+ * is considered invalid.
+ */
+export function isParameterValueValid(
+  type: ParameterType,
+  value: unknown,
+  isVariadic: boolean = false,
+): boolean {
+  const validator = parameterTypeValidators[type];
+
+  if (isVariadic) {
+    return Array.isArray(value) && value.length > 0 && value.every(validator);
+  }
+
+  return validator(value);
+}
+
+const parameterTypeValidators: Record<
+  ParameterType,
+  (value: unknown) => boolean
+> = {
+  [ParameterType.STRING]: (value): value is string => typeof value === "string",
+  [ParameterType.BOOLEAN]: (value): value is boolean =>
+    typeof value === "boolean",
+  [ParameterType.INT]: (value): value is number => Number.isInteger(value),
+  [ParameterType.BIGINT]: (value): value is bigint => typeof value === "bigint",
+  [ParameterType.FLOAT]: (value): value is number => typeof value === "number",
+  [ParameterType.FILE]: (value): value is string => typeof value === "string",
+};

v-next/core/src/internal/tasks/builders.ts

@@ -14,10 +14,11 @@ import type {
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
 
-import { ParameterType, isParameterValueValid } from "../../types/common.js";
+import { ParameterType } from "../../types/common.js";
 import { TaskDefinitionType } from "../../types/tasks.js";
 import {
   RESERVED_PARAMETER_NAMES,
+  isParameterValueValid,
   isValidParamNameCasing,
 } from "../parameters.js";
 

v-next/core/src/internal/tasks/resolved-task.ts

@@ -14,7 +14,7 @@ import type {
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 
-import { isParameterValueValid } from "../../types/common.js";
+import { isParameterValueValid } from "../parameters.js";
 
 import { formatTaskId } from "./utils.js";
 

v-next/core/src/types/common.ts

@@ -44,38 +44,3 @@ export type ParameterValue =
  */
 export type ParameterTypeToValueType<T extends ParameterType> =
   ParameterToValueTypeMap[T];
-
-const parameterTypeValidators: Record<
-  ParameterType,
-  (value: unknown) => boolean
-> = {
-  [ParameterType.STRING]: (value): value is string => typeof value === "string",
-  [ParameterType.BOOLEAN]: (value): value is boolean =>
-    typeof value === "boolean",
-  [ParameterType.INT]: (value): value is number => Number.isInteger(value),
-  [ParameterType.BIGINT]: (value): value is bigint => typeof value === "bigint",
-  [ParameterType.FLOAT]: (value): value is number => typeof value === "number",
-  [ParameterType.FILE]: (value): value is string => typeof value === "string",
-};
-
-/**
- * Checks if a parameter value is valid for a given parameter type.
- *
- * This function uses a map of validators, where each validator is a function
- * that checks if a value is valid for a specific parameter type.
- * If the parameter type is variadic, the value is considered valid if it is an
- * array and all its elements are valid for the parameter type.
- */
-export function isParameterValueValid(
-  type: ParameterType,
-  value: unknown,
-  isVariadic: boolean = false,
-): boolean {
-  const validator = parameterTypeValidators[type];
-
-  if (isVariadic) {
-    return Array.isArray(value) && value.every(validator);
-  }
-
-  return validator(value);
-}

v-next/core/test/internal/parameters.ts

@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { ParameterType } from "../../src/config.js";
+import {
+  isValidParamNameCasing,
+  isParameterValueValid,
+} from "../../src/internal/parameters.js";
+
+describe("Parameters", () => {
+  describe("isValidParamNameCasing", () => {
+    it("should return true for valid parameter names", () => {
+      assert.equal(isValidParamNameCasing("a"), true);
+      assert.equal(isValidParamNameCasing("aa"), true);
+      assert.equal(isValidParamNameCasing("aA"), true);
+      assert.equal(isValidParamNameCasing("a1"), true);
+      assert.equal(isValidParamNameCasing("foo"), true);
+      assert.equal(isValidParamNameCasing("fooBar"), true);
+      assert.equal(isValidParamNameCasing("foo123"), true);
+    });
+
+    it("should return false for invalid parameter names", () => {
+      assert.equal(isValidParamNameCasing("A"), false);
+      assert.equal(isValidParamNameCasing("1"), false);
+      assert.equal(isValidParamNameCasing("-"), false);
+      assert.equal(isValidParamNameCasing("Foo"), false);
+      assert.equal(isValidParamNameCasing("123Foo"), false);
+      assert.equal(isValidParamNameCasing("foo-bar"), false);
+    });
+  });
+
+  describe("isParameterValueValid", () => {
+    it("should validate string parameters", () => {
+      assert.equal(isParameterValueValid(ParameterType.STRING, "foo"), true);
+      assert.equal(isParameterValueValid(ParameterType.STRING, 123), false);
+    });
+
+    it("should validate boolean parameters", () => {
+      assert.equal(isParameterValueValid(ParameterType.BOOLEAN, true), true);
+      assert.equal(isParameterValueValid(ParameterType.BOOLEAN, "true"), false);
+    });
+
+    it("should validate int parameters", () => {
+      assert.equal(isParameterValueValid(ParameterType.INT, 123), true);
+      assert.equal(isParameterValueValid(ParameterType.INT, 123.45), false);
+      assert.equal(isParameterValueValid(ParameterType.INT, 123n), false);
+    });
+
+    it("should validate bigint parameters", () => {
+      assert.equal(
+        isParameterValueValid(ParameterType.BIGINT, BigInt(123)),
+        true,
+      );
+      assert.equal(isParameterValueValid(ParameterType.BIGINT, 123n), true);
+      assert.equal(isParameterValueValid(ParameterType.BIGINT, 123), false);
+    });
+
+    it("should validate float parameters", () => {
+      assert.equal(isParameterValueValid(ParameterType.FLOAT, 123), true);
+      assert.equal(isParameterValueValid(ParameterType.FLOAT, 123.45), true);
+      assert.equal(isParameterValueValid(ParameterType.FLOAT, 123n), false);
+    });
+
+    it("should validate file parameters", () => {
+      assert.equal(isParameterValueValid(ParameterType.FILE, "foo.txt"), true);
+      assert.equal(
+        isParameterValueValid(ParameterType.FILE, "random string"),
+        true,
+      );
+      assert.equal(isParameterValueValid(ParameterType.FILE, 123), false);
+    });
+
+    it("should validate variadic parameters", () => {
+      assert.equal(
+        isParameterValueValid(ParameterType.STRING, ["foo", "bar"], true),
+        true,
+      );
+      assert.equal(
+        isParameterValueValid(ParameterType.BIGINT, [123n, BigInt(123)], true),
+        true,
+      );
+      assert.equal(
+        isParameterValueValid(ParameterType.STRING, [], true),
+        false,
+      );
+      assert.equal(
+        isParameterValueValid(ParameterType.STRING, ["foo", 123], true),
+        false,
+      );
+    });
+  });
+});