eslint-config-matsuri 1.4.1-alpha-c387b34.0 → 1.5.0

package/index.js

@@ -1,5 +1,5 @@
 const rulesDirPlugin = require("eslint-plugin-rulesdir");
-rulesDirPlugin.RULES_DIR = "./rules";
+rulesDirPlugin.RULES_DIR = __dirname + "/rules";
 
 /** @type {import('eslint').Linter.BaseConfig} */
 const config = {

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "eslint-config-matsuri",
-  "version": "1.4.1-alpha-c387b34.0",
+  "version": "1.5.0",
   "description": "",
   "main": "index.js",
   "files": [
-    "index.js"
+    "index.js",
+    "rules"
   ],
   "scripts": {
     "test": "eslint . --max-warnings 0"

package/rules/naming-convention.js

@@ -0,0 +1,160 @@
+const REGEX_CAMEL_CASE = /^[a-z][a-zA-Z0-9]*$/;
+const REGEX_PASCAL_CASE = /^[A-Z][a-zA-Z0-9]*$/;
+const REGEX_UPPER_CASE = /^[A-Z][A-Z0-9_]*$/;
+const REGEX_SNAKE_CASE = /^[a-z][a-z0-9_]*$/;
+
+const isCamelCase = (name) => REGEX_CAMEL_CASE.test(name);
+const isPascalCase = (name) => REGEX_PASCAL_CASE.test(name);
+const isUpperCase = (name) => REGEX_UPPER_CASE.test(name);
+const isSnakeCase = (name) => REGEX_SNAKE_CASE.test(name);
+
+const toCamelCase = (name) => {
+  if (isCamelCase(name)) {
+    return name;
+  }
+  if (isPascalCase(name)) {
+    return name[0].toLowerCase() + name.slice(1);
+  }
+  if (isUpperCase(name) || isSnakeCase(name)) {
+    const tmp = name
+      .split("_")
+      .map((word) => word[0].toUpperCase() + word.slice(1))
+      .join("");
+    return tmp[0].toLowerCase() + tmp.slice(1);
+  }
+  return name;
+};
+
+const checkValidity = (name, format) => {
+  switch (format) {
+    case "camelCase": {
+      return isCamelCase(name);
+    }
+    case "PascalCase": {
+      return isPascalCase(name);
+    }
+    case "UPPER_CASE": {
+      return isUpperCase(name);
+    }
+  }
+};
+
+const trimUnderscore = (name, leadingUnderscore, trailingUnderscore) => {
+  if (leadingUnderscore === "allow" && name?.startsWith("_")) {
+    return name.slice(1);
+  }
+  if (trailingUnderscore === "allow" && name?.endsWith("_")) {
+    return name.slice(0, -1);
+  }
+  return name;
+};
+
+const reportValidity = (
+  context,
+  node,
+  format,
+  fix,
+  leadingUnderscore,
+  trailingUnderscore
+) => {
+  if (node.id === null) {
+    return;
+  }
+  const valid = format.some((format) => {
+    const name = trimUnderscore(
+      node.id.name,
+      leadingUnderscore,
+      trailingUnderscore
+    );
+    return checkValidity(name, format);
+  });
+
+  if (valid === false) {
+    context.report({
+      node,
+      message: `${node.id.name} must be ${format.join(" or ")}`,
+      fix: (fixer) => {
+        switch (fix) {
+          case "camelCase": {
+            return fixer.replaceText(node.id, toCamelCase(node.id.name));
+          }
+          default: {
+            return fixer.replaceText(node.id, node.id.name);
+          }
+        }
+      },
+    });
+  }
+};
+
+const options = {
+  validable: {
+    format: ["camelCase", "UPPER_CASE"],
+    fix: "camelCase",
+    leadingUnderscore: "allow",
+    trailingUnderscore: "allow",
+  },
+  function: {
+    format: ["camelCase", "PascalCase"],
+    fix: "camelCase",
+    leadingUnderscore: "allow",
+    trailingUnderscore: "allow",
+  },
+};
+
+/**
+ * @type {import("eslint").Rule.RuleModule}
+ */
+const rule = {
+  meta: {
+    type: "problem",
+    fixable: "code",
+  },
+  create: (context) => {
+    return {
+      VariableDeclarator: (node) => {
+        if (node.init?.type === "ArrowFunctionExpression") {
+          reportValidity(
+            context,
+            node,
+            options.function.format,
+            options.function.fix,
+            options.function.leadingUnderscore,
+            options.function.trailingUnderscore
+          );
+        } else {
+          reportValidity(
+            context,
+            node,
+            options.validable.format,
+            options.validable.fix,
+            options.validable.leadingUnderscore,
+            options.validable.trailingUnderscore
+          );
+        }
+      },
+      FunctionDeclaration: (node) => {
+        reportValidity(
+          context,
+          node,
+          options.function.format,
+          options.function.fix,
+          options.function.leadingUnderscore,
+          options.function.trailingUnderscore
+        );
+      },
+      FunctionExpression: (node) => {
+        reportValidity(
+          context,
+          node,
+          options.function.format,
+          options.function.fix,
+          options.function.leadingUnderscore,
+          options.function.trailingUnderscore
+        );
+      },
+    };
+  },
+};
+
+module.exports = rule;