feat: add rule to prove that a hexadecimal number is less than 256

Author: 0xflotus

Diff for: .gitignore

@@ -0,0 +1 @@
+node_modules

Diff for: README.md

@@ -0,0 +1,18 @@
+# eslint-plugin-hex-under
+
+## hex-under-256
+
+This ESLint plugin proves, if you use hexadecimal numbers in your variable declaration code, that its value is less than 256. If you use a hexadecimal number greater or equal 256, it will be transformed to its decimal value.
+
+### Example
+
+```js
+// valid
+const signal = 0xef;
+
+// invalid
+const signal = 0x21b;
+
+// This will be transformed to:
+const signal = 539;
+```

Diff for: eslint-plugin-hex-under.js

@@ -0,0 +1,3 @@
+const hexUnder256Rule = require("./hex-under-256");
+const plugin = { rules: { "hex-under-256": hexUnder256Rule } };
+module.exports = plugin;

Diff for: eslint.config.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const eslintPluginHexUnder = require("./eslint-plugin-hex-under");
+
+module.exports = [
+  {
+    files: ["*.js"],
+    plugins: {
+      "hex-under": eslintPluginHexUnder,
+    },
+    rules: {
+      "hex-under/hex-under-256": "error",
+    },
+  },
+];

Diff for: hex-under-256.js

@@ -0,0 +1,46 @@
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Proves that a hexadecimal number must be less than 256.",
+    },
+    fixable: "code",
+    schema: [],
+  },
+  create(context) {
+    return {
+      VariableDeclarator(node) {
+        if (
+          node.parent.kind === "const" ||
+          node.parent.kind === "let" ||
+          node.parent.kind === "var"
+        ) {
+          if (
+            node.init &&
+            node.init.type === "Literal" &&
+            node.init.raw.startsWith("0x")
+          ) {
+            const limit = 0xff;
+            if (parseInt(node.init.value) > limit) {
+              context.report({
+                node,
+                message:
+                  "Value of '{{ variableName }}' must be less than 256. {{ over255Raw }} is greater than 255.",
+                data: {
+                  over255Raw: node.init.raw,
+                  variableName: node.id.name,
+                },
+                fix(fixer) {
+                  return fixer.replaceText(
+                    node.init,
+                    parseInt(node.init.value),
+                  );
+                },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};

Diff for: hex-under-256.test.js

@@ -0,0 +1,53 @@
+const { RuleTester } = require("eslint");
+const hexUnder256Rule = require("./hex-under-256");
+
+const ruleTester = new RuleTester({
+  languageOptions: { ecmaVersion: 2015 },
+});
+
+ruleTester.run("hex-under-256", hexUnder256Rule, {
+  valid: [
+    {
+      code: "const foo = 0xff;",
+    },
+  ],
+  invalid: [
+    {
+      code: "const foo = 0x100;",
+      output: "const foo = 256;",
+      errors: 1,
+    },
+  ],
+});
+
+ruleTester.run("hex-under-256", hexUnder256Rule, {
+  valid: [
+    {
+      code: "let foo = 0xff;",
+    },
+  ],
+  invalid: [
+    {
+      code: "let foo = 0x100;",
+      output: "let foo = 256;",
+      errors: 1,
+    },
+  ],
+});
+
+ruleTester.run("hex-under-256", hexUnder256Rule, {
+  valid: [
+    {
+      code: "var foo = 0xff;",
+    },
+  ],
+  invalid: [
+    {
+      code: "var foo = 0x100;",
+      output: "var foo = 256;",
+      errors: 1,
+    },
+  ],
+});
+
+console.log("All tests passed!");