export and test parseParameterValue

Author: zoeyTM

v-next/core/src/index.ts

@@ -31,5 +31,6 @@ export async function createBaseHardhatRuntimeEnvironment(
   );
 }
 
+export { parseArgumentValue } from "./internal/arguments.js";
 export { resolvePluginList } from "./internal/plugins/resolve-plugin-list.js";
 export { buildGlobalOptionDefinitions } from "./internal/global-options.js";

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

@@ -57,9 +57,11 @@ const argumentTypeValidators: Record<
 
 /**
  * Parses an argument value from a string to the corresponding type.
+ *
+ * @param value - The string value to parse.
+ * @param type - The type of the argument.
+ * @param name - The name of the argument.
  */
-// TODO: this code is duplicated in v-next/hardhat/src/internal/cli/main.ts
-// we should move it to a shared place and add tests
 export function parseArgumentValue(
   value: string,
   type: ArgumentType,

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

@@ -1,10 +1,14 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 
+import { HardhatError } from "@ignored/hardhat-vnext-errors";
+import { assertThrowsHardhatError } from "@nomicfoundation/hardhat-test-utils";
+
 import { ArgumentType } from "../../src/config.js";
 import {
   isArgumentNameValid,
   isArgumentValueValid,
+  parseArgumentValue,
 } from "../../src/internal/arguments.js";
 
 describe("Arguments", () => {
@@ -86,4 +90,87 @@ describe("Arguments", () => {
       );
     });
   });
+
+  describe("parseArgumentValue", () => {
+    it("should parse string arguments", () => {
+      assert.equal(
+        parseArgumentValue("foo", ArgumentType.STRING, "name"),
+        "foo",
+      );
+    });
+
+    it("should parse file arguments", () => {
+      assert.equal(
+        parseArgumentValue("foo.txt", ArgumentType.FILE, "name"),
+        "foo.txt",
+      );
+    });
+
+    it("should parse int arguments", () => {
+      assert.equal(parseArgumentValue("123", ArgumentType.INT, "name"), 123);
+    });
+
+    it("should parse float arguments", () => {
+      assert.equal(
+        parseArgumentValue("123.45", ArgumentType.FLOAT, "name"),
+        123.45,
+      );
+    });
+
+    it("should parse bigint arguments", () => {
+      assert.equal(
+        parseArgumentValue("123", ArgumentType.BIGINT, "name"),
+        BigInt(123),
+      );
+    });
+
+    it("should parse boolean arguments", () => {
+      assert.equal(
+        parseArgumentValue("true", ArgumentType.BOOLEAN, "name"),
+        true,
+      );
+    });
+
+    describe("should throw an error for invalid values", () => {
+      it("for int arguments", () => {
+        assertThrowsHardhatError(
+          () => {
+            parseArgumentValue("foo", ArgumentType.INT, "name");
+          },
+          HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
+          { value: "foo", name: "name", type: ArgumentType.INT },
+        );
+      });
+
+      it("for float arguments", () => {
+        assertThrowsHardhatError(
+          () => {
+            parseArgumentValue("foo", ArgumentType.FLOAT, "name");
+          },
+          HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
+          { value: "foo", name: "name", type: ArgumentType.FLOAT },
+        );
+      });
+
+      it("for bigint arguments", () => {
+        assertThrowsHardhatError(
+          () => {
+            parseArgumentValue("foo", ArgumentType.BIGINT, "name");
+          },
+          HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
+          { value: "foo", name: "name", type: ArgumentType.BIGINT },
+        );
+      });
+
+      it("for boolean arguments", () => {
+        assertThrowsHardhatError(
+          () => {
+            parseArgumentValue("foo", ArgumentType.BOOLEAN, "name");
+          },
+          HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
+          { value: "foo", name: "name", type: ArgumentType.BOOLEAN },
+        );
+      });
+    });
+  });
 });

v-next/hardhat/src/internal/cli/main.ts

@@ -1,4 +1,3 @@
-import type { ArgumentValue } from "@ignored/hardhat-vnext-core/types/arguments";
 import type {
   GlobalOptions,
   GlobalOptionDefinition,
@@ -16,6 +15,7 @@ import "tsx"; // NOTE: This is important, it allows us to load .ts files form th
 
 import {
   buildGlobalOptionDefinitions,
+  parseArgumentValue,
   resolvePluginList,
 } from "@ignored/hardhat-vnext-core";
 import { ArgumentType } from "@ignored/hardhat-vnext-core/types/arguments";
@@ -521,110 +521,3 @@ function validateRequiredArguments(
     { argument: missingRequiredArgument.name },
   );
 }
-
-function parseArgumentValue(
-  strValue: string,
-  type: ArgumentType,
-  argName: string,
-): ArgumentValue {
-  switch (type) {
-    case ArgumentType.STRING:
-      return validateAndParseString(argName, strValue);
-    case ArgumentType.FILE:
-      return validateAndParseFile(argName, strValue);
-    case ArgumentType.INT:
-      return validateAndParseInt(argName, strValue);
-    case ArgumentType.FLOAT:
-      return validateAndParseFloat(argName, strValue);
-    case ArgumentType.BIGINT:
-      return validateAndParseBigInt(argName, strValue);
-    case ArgumentType.BOOLEAN:
-      return validateAndParseBoolean(argName, strValue);
-  }
-}
-
-function validateAndParseInt(argName: string, strValue: string): number {
-  const decimalPattern = /^\d+(?:[eE]\d+)?$/;
-  const hexPattern = /^0[xX][\dABCDEabcde]+$/;
-
-  if (
-    strValue.match(decimalPattern) === null &&
-    strValue.match(hexPattern) === null
-  ) {
-    throw new HardhatError(
-      HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
-      {
-        value: strValue,
-        name: argName,
-        type: "int",
-      },
-    );
-  }
-
-  return Number(strValue);
-}
-
-function validateAndParseString(_argName: string, strValue: string): string {
-  return strValue;
-}
-
-function validateAndParseFile(_argName: string, strValue: string): string {
-  return strValue;
-}
-
-function validateAndParseFloat(argName: string, strValue: string): number {
-  const decimalPattern = /^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE]\d+)?$/;
-  const hexPattern = /^0[xX][\dABCDEabcde]+$/;
-
-  if (
-    strValue.match(decimalPattern) === null &&
-    strValue.match(hexPattern) === null
-  ) {
-    throw new HardhatError(
-      HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
-      {
-        value: strValue,
-        name: argName,
-        type: "float",
-      },
-    );
-  }
-
-  return Number(strValue);
-}
-
-function validateAndParseBigInt(argName: string, strValue: string): bigint {
-  const decimalPattern = /^\d+(?:n)?$/;
-  const hexPattern = /^0[xX][\dABCDEabcde]+$/;
-
-  if (
-    strValue.match(decimalPattern) === null &&
-    strValue.match(hexPattern) === null
-  ) {
-    throw new HardhatError(
-      HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
-      {
-        value: strValue,
-        name: argName,
-        type: "bigint",
-      },
-    );
-  }
-
-  return BigInt(strValue.replace("n", ""));
-}
-
-function validateAndParseBoolean(argName: string, strValue: string): boolean {
-  if (strValue.toLowerCase() === "true") {
-    return true;
-  }
-  if (strValue.toLowerCase() === "false") {
-    return false;
-  }
-
-  throw new HardhatError(HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
-    value: strValue,
-    name: argName,
-    type: "boolean",
-  });
-}