eslint-plugin-hex-under 0.5.1 → 0.6.0

package/README.md

@@ -2,6 +2,23 @@
 
 Sometimes it's really hard for humans to read hexadecimal numbers and know the exact decimal value.
 
+## Testing & Code Coverage
+
+This project uses **Vitest** as its test runner with comprehensive code coverage tracking. All tests are written using Vitest's modern testing framework and ESLint's RuleTester for validating rule behavior.
+
+### Running Tests
+
+```sh
+# Run all tests once
+npm run test
+
+# Run tests in watch mode (for development)
+npm run test:watch
+
+# Run tests with coverage report
+npm run coverage
+```
+
 ## hex-under
 
 This ESLint plugin proves, if you use hexadecimal numbers in your code, that its value is less than or equal a specified value (default: 255). If you use a hexadecimal number greater than this specified value, it will be transformed to its decimal value.

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "eslint-plugin-hex-under",
-  "version": "0.5.1",
+  "version": "0.6.0",
+  "type": "module",
   "main": "src/eslint-plugin-hex-under.js",
   "scripts": {
     "lint": "prettier . --check && eslint .",
-    "test": "npm run test:hex-under && npm run test:bigint",
-    "test:hex-under": "node test/hex-under.test.js",
-    "test:bigint": "node test/hex-under-bigint.test.js"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage"
   },
   "repository": {
     "type": "git",
@@ -17,8 +18,11 @@
   "license": "MIT",
   "description": "This ESLint rule proves that hex numbers are less than a specified value.",
   "devDependencies": {
+    "@vitest/coverage-v8": "4.1.0",
     "eslint": "10.0.3",
-    "prettier": "3.8.1"
+    "prettier": "3.8.1",
+    "tinyexec": "1.0.4",
+    "vitest": "4.1.0"
   },
   "peerDependencies": {
     "eslint": "^10.0.0"

package/src/eslint-plugin-hex-under.js

@@ -1,9 +1,11 @@
-const hexUnderRule = require("./rules/hex-under");
-const hexUnderBigintRule = require("./rules/hex-under-bigint");
+import hexUnderRule from "./rules/hex-under.js";
+import hexUnderBigintRule from "./rules/hex-under-bigint.js";
+
 const plugin = {
   rules: {
     "hex-under": hexUnderRule,
     "hex-under-bigint": hexUnderBigintRule,
   },
 };
-module.exports = plugin;
+
+export default plugin;

package/src/rules/hex-under-bigint.js

@@ -0,0 +1,74 @@
+export default {
+  meta: {
+    type: "suggestion",
+    version: "0.0.2",
+    defaultOptions: [
+      {
+        limit: 255,
+      },
+    ],
+    docs: {
+      description:
+        "Proves that a hexadecimal bigint must be less than a specified value. Default is 255.",
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          limit: {
+            type: "integer",
+            minimum: 0,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      valueOverGeneralBigInt:
+        "This bigint must be less than or equal {{ limit }}. {{ overValue }} ({{ over255Raw }}) is greater than {{ limit }}.",
+    },
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const limit = typeof options.limit === "number" ? options.limit : 255;
+
+    return {
+      onCodePathEnd: function (_codePath, node) {
+        const tokens =
+          node.tokens?.filter(
+            (token) =>
+              ["Numeric", "Identifier"].includes(token.type) &&
+              typeof token.value === "string" &&
+              token.value.startsWith("0x") &&
+              token.value.endsWith("n"),
+          ) || [];
+
+        for (const token of tokens) {
+          try {
+            const hexValue = token.value.slice(0, -1);
+            const value = BigInt(hexValue);
+            const limitBigInt = BigInt(limit);
+
+            if (value > limitBigInt) {
+              context.report({
+                node: token,
+                messageId: "valueOverGeneralBigInt",
+                data: {
+                  limit: limit,
+                  over255Raw: token.value,
+                  overValue: value.toString(),
+                },
+                fix(fixer) {
+                  return fixer.replaceText(token, value.toString() + "n");
+                },
+              });
+            }
+          } catch {
+            continue;
+          }
+        }
+      },
+    };
+  },
+};

package/src/rules/hex-under.js

@@ -0,0 +1,76 @@
+export default {
+  meta: {
+    type: "suggestion",
+    version: "0.3.0",
+    defaultOptions: [
+      {
+        limit: 255,
+      },
+    ],
+    docs: {
+      description:
+        "Proves that a hexadecimal number must be less than a specified value. Default is 255.",
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          limit: {
+            type: "integer",
+            minimum: 0,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      valueOverGeneral:
+        "This number must be less than or equal {{ limit }}. {{ overValue }} ({{ over255Raw }}) is greater than {{ limit }}.",
+    },
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const limit = typeof options.limit === "number" ? options.limit : 255;
+
+    return {
+      onCodePathEnd: function (_codePath, node) {
+        const tokens =
+          node.tokens?.filter(
+            (token) =>
+              ["Numeric", "Identifier"].includes(token.type) &&
+              typeof token.value === "string" &&
+              token.value.startsWith("0x") &&
+              !token.value.endsWith("n"),
+          ) || [];
+
+        for (const token of tokens) {
+          try {
+            const value = parseInt(token.value, 16);
+
+            if (isNaN(value)) {
+              continue;
+            }
+
+            if (value > limit) {
+              context.report({
+                node: token,
+                messageId: "valueOverGeneral",
+                data: {
+                  limit: limit,
+                  over255Raw: token.value,
+                  overValue: value,
+                },
+                fix(fixer) {
+                  return fixer.replaceText(token, String(value));
+                },
+              });
+            }
+          } catch {
+            continue;
+          }
+        }
+      },
+    };
+  },
+};