eslint-plugin-hex-under 0.1.4 → 0.2.2

package/README.md

@@ -1,8 +1,10 @@
 # eslint-plugin-hex-under
 
+Sometimes it's really hard for humans to read hexadecimal numbers and know the exact decimal value. 
+
 ## hex-under
 
-This ESLint plugin proves, if you use hexadecimal numbers in your variable declaration 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.
+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.
 
 ### Example
 
@@ -10,11 +12,30 @@ This ESLint plugin proves, if you use hexadecimal numbers in your variable decla
 // valid with { limit: 255 }
 const signal = 0xef;
 
+let func = () => 0xab;
+
+function add(a, b) {
+  return a + b + 0x1f;
+}
+
 // invalid with { limit: 255 }
 const signal = 0x21b;
 
+let func = () => 0xabc;
+
+function add(a, b) {
+  return a + b + 0x100;
+}
+
 // This can be transformed to:
 const signal = 539;
+
+let func = () => 2748;
+
+function add(a, b) {
+  return a + b + 256;
+}
+
 ```
 
 ## Integration

package/hex-under.js

@@ -19,38 +19,32 @@ module.exports = {
       },
     ],
     messages: {
-      valueOver:
-        "Value of '{{ variableName }}' must be less than or equal {{ limit }}. {{ overValue }} ({{ over255Raw }}) is greater than {{ limit }}.",
+      valueOverGeneral:
+        "This number must be less than or equal {{ limit }}. {{ overValue }} ({{ over255Raw }}) is greater than {{ limit }}.",
     },
   },
   create(context) {
     const limit = context.options[0]?.limit || 255;
     return {
-      VariableDeclarator(node) {
-        if (["const", "let", "var"].some((el) => el === node.parent.kind)) {
-          if (
-            node.init &&
-            node.init.type === "Literal" &&
-            node.init.raw.startsWith("0x")
-          ) {
-            if (parseInt(node.init.value) > limit) {
-              context.report({
-                node,
-                messageId: "valueOver",
-                data: {
-                  limit: limit,
-                  over255Raw: node.init.raw,
-                  overValue: node.init.value,
-                  variableName: node.id.name,
-                },
-                fix(fixer) {
-                  return fixer.replaceText(
-                    node.init,
-                    parseInt(node.init.value),
-                  );
-                },
-              });
-            }
+      onCodePathEnd: function (_codePath, node) {
+        const tokens =
+          node.tokens?.filter(
+            (token) => token.type === "Numeric" && token.value.startsWith("0x"),
+          ) || [];
+        for (const token of tokens) {
+          if (token.value > limit) {
+            context.report({
+              node: token,
+              messageId: "valueOverGeneral",
+              data: {
+                limit: limit,
+                over255Raw: token.value,
+                overValue: parseInt(token.value),
+              },
+              fix(fixer) {
+                return fixer.replaceText(token, parseInt(token.value));
+              },
+            });
           }
         }
       },

package/hex-under.test.js

@@ -15,6 +15,23 @@ ruleTester.run("hex-under", hexUnderRule, {
       options: [{ limit: 256 }],
       code: "const foo = 0x100;",
     },
+    {
+      options: [{ limit: 255 }],
+      code: "let foo = 0xff;",
+    },
+    {
+      options: [{ limit: 256 }],
+      code: "var foo = 0xff;",
+    },
+    {
+      code: "function func() {\n  return 0xff;\n}",
+    },
+    {
+      code: "functionA(0xef);",
+    },
+    {
+      code: "const func = () => 0xab;",
+    },
   ],
   invalid: [
     {
@@ -22,38 +39,31 @@ ruleTester.run("hex-under", hexUnderRule, {
       output: "const foo = 256;",
       errors: 1,
     },
-  ],
-});
-
-ruleTester.run("hex-under", hexUnderRule, {
-  valid: [
-    {
-      options: [{ limit: 255 }],
-      code: "let foo = 0xff;",
-    },
-  ],
-  invalid: [
     {
       code: "let foo = 0x100;",
       output: "let foo = 256;",
       errors: 1,
     },
-  ],
-});
-
-ruleTester.run("hex-under", hexUnderRule, {
-  valid: [
-    {
-      options: [{ limit: 256 }],
-      code: "var foo = 0xff;",
-    },
-  ],
-  invalid: [
     {
       code: "var foo = 0x100;",
       output: "var foo = 256;",
       errors: 1,
     },
+    {
+      code: "function func() {\n  return 0x100;\n}",
+      output: "function func() {\n  return 256;\n}",
+      errors: 1,
+    },
+    {
+      code: "functionA(0x1234);",
+      output: "functionA(4660);",
+      errors: 1,
+    },
+    {
+      code: "const func = () => 0xabc;",
+      output: "const func = () => 2748;",
+      errors: 1,
+    },
   ],
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-hex-under",
-  "version": "0.1.4",
+  "version": "0.2.2",
   "main": "eslint-plugin-hex-under.js",
   "scripts": {
     "lint": "prettier . --check && eslint .",

package/.github/workflows/build-and-test.yml

@@ -1,39 +0,0 @@
-name: Build and Test
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  lint:
-    name: Linting
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 22
-      - run: npm install
-      - name: Run Linting
-        run: DEBUG=eslint:eslint npm run lint
-  build:
-    name: Testing
-    needs: lint
-    strategy:
-      matrix:
-        os: [ubuntu-latest, ubuntu-24.04-arm]
-        node-version: [18, 20, 22]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-      - run: npm install
-      - run: npm test