eslint-plugin-crisp 1.4.17 → 1.4.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-crisp",
-  "version": "1.4.17",
+  "version": "1.4.18",
   "description": "Custom ESLint Rules for Crisp",
   "author": "Crisp IM SAS",
   "main": "index.js",

package/recommended-vue.js

@@ -168,6 +168,7 @@ export default function configRecommendedVue(pluginCrisp) {
         // Crisp JS rules
         "crisp/align-comments": "error",
         "crisp/consecutive-line-comments": "error",
+        "crisp/const": "error",
         "crisp/enforce-optional": "error",
         "crisp/header-check": "error",
         "crisp/header-comments-check": "error",

package/rules/const.js

@@ -1,27 +1,159 @@
+const isTopLevelDeclaration = (node) => {
+  let parent = node.parent;
+
+  if (parent?.type === "ExportNamedDeclaration") {
+    parent = parent.parent;
+  }
+
+  return parent?.type === "Program";
+};
+
+const isExportedDeclaration = (node) => {
+  return node.parent?.type === "ExportNamedDeclaration";
+};
+
+const isCallOrConstruction = (node) => {
+  return node?.type === "CallExpression" || node?.type === "NewExpression";
+};
+
+const isFunctionExpression = (node) => {
+  return (
+    node?.type === "ArrowFunctionExpression" ||
+    node?.type === "FunctionExpression"
+  );
+};
+
 export default {
   meta: {
     type: "suggestion",
     docs: {
-      description: "enforce that consts are uppercase or start with \"__\"",
+      description:
+        "Enforce top-level uppercase or double-underscore constant names.",
       category: "Stylistic Issues",
-      recommended: false,
+      recommended: false
     },
-    schema: [], // no options
+    fixable: "code",
+
+    schema: [{
+      type: "object",
+      properties: {
+        exceptions: {
+          type: "array",
+          items: { type: "string" },
+          uniqueItems: true
+        }
+      },
+      additionalProperties: false
+    }]
   },
+
   create(context) {
+    const options = context.options[0] || {};
+    const exceptions = options.exceptions || [];
+    const sourceCode = context.sourceCode || context.getSourceCode();
+
+    const isTopLevelCallArgument = (identifier) => {
+      let scope = sourceCode.getScope(identifier);
+      let variable;
+
+      while (scope && !variable) {
+        variable = scope.set.get(identifier.name);
+        scope = scope.upper;
+      }
+
+      return variable?.references.some((reference) => {
+        const parent = reference.identifier.parent;
+
+        return (
+          isCallOrConstruction(parent) &&
+          parent.arguments.includes(reference.identifier)
+        );
+      }) || false;
+    };
+
     return {
       VariableDeclaration(node) {
-        if (node.kind === "const") {
-          node.declarations.forEach((declaration) => {
-            if (declaration.id && declaration.id.name && (!declaration.id.name.startsWith("__") || declaration.id.name.toUpperCase() !== declaration.id.name)) {
-              context.report({
-                node: declaration,
-                message: "Consts should be uppercase and start with \"__\"",
-              });
+        if (node.kind !== "const") {
+          return;
+        }
+
+        const isTopLevel = isTopLevelDeclaration(node);
+        const isExported = isExportedDeclaration(node);
+        const hasOnlyDestructuring = node.declarations.every((declaration) => {
+          return declaration.id.type !== "Identifier";
+        });
+        const canReplaceWithLet = node.declarations.every((declaration) => {
+          if (declaration.id.type !== "Identifier") {
+            return true;
+          }
+
+          const name = declaration.id.name;
+          const isValidConst =
+            exceptions.includes(name) ||
+            (
+              name.startsWith("__") &&
+              name.toUpperCase() === name
+            );
+
+          return name.startsWith("_") && !isValidConst;
+        });
+
+        if (!isTopLevel && !isExported && canReplaceWithLet) {
+          context.report({
+            node,
+            message: hasOnlyDestructuring
+              ? "Local destructuring declarations should use \"let\"."
+              : "Local variables prefixed with \"_\" should use \"let\".",
+            fix(fixer) {
+              return fixer.replaceText(sourceCode.getFirstToken(node), "let");
             }
           });
+
+          return;
         }
-      },
+
+        node.declarations.forEach((declaration) => {
+          if (declaration.id.type !== "Identifier") {
+            if (isTopLevel || isExported) {
+              return;
+            }
+
+            context.report({
+              node: declaration,
+              message: "Local destructuring declarations should use \"let\"."
+            });
+
+            return;
+          }
+
+          const name = declaration.id.name;
+          const isUppercase = name.toUpperCase() === name;
+          const hasValidPlacement =
+            isTopLevel || name.startsWith("__");
+          const isTopLevelBuilder =
+            isTopLevel && isCallOrConstruction(declaration.init);
+          const isTopLevelBuilderArgument =
+            isTopLevel && isTopLevelCallArgument(declaration.id);
+          const isFunction = isFunctionExpression(declaration.init);
+
+          if (
+            isExported ||
+            isTopLevelBuilder ||
+            isTopLevelBuilderArgument ||
+            isFunction ||
+            exceptions.includes(name) ||
+            (isUppercase && hasValidPlacement)
+          ) {
+            return;
+          }
+
+          context.report({
+            node: declaration.id,
+            message:
+              "Consts should be uppercase and defined at the top level or be replaced with let _variable (Crisp convention)."
+          });
+        });
+      }
     };
-  },
+  }
 };

package/rules/variable-names.js

@@ -1,8 +1,26 @@
+const isLocalDeclaration = (node) => {
+  let parent = node.parent;
+
+  while (parent) {
+    if (
+      parent.type === "ArrowFunctionExpression" ||
+      parent.type === "FunctionDeclaration" ||
+      parent.type === "FunctionExpression"
+    ) {
+      return true;
+    }
+
+    parent = parent.parent;
+  }
+
+  return false;
+};
+
 export default {
   meta: {
     type: "suggestion",
     docs: {
-      description: "enforce that variables defined within a method start with '_', except for parameters",
+      description: "Enforce that local variable names follow internal conventions.",
       category: "Stylistic Issues",
       recommended: false
     },
@@ -24,110 +42,27 @@ export default {
     const options = context.options[0] || {};
     const variableExceptions = options.variableExceptions || [];
 
-    function checkDeclaration(node) {
-      if (!node) {
-        return;
-      }
-
-      switch(node.type) {
-        // In case of a variable declaration, it checks if the variable name \
-        //   starts with "_" or is an exception
-        case "VariableDeclaration": {
-          node.declarations.forEach((declaration) => {
-            if (declaration.id.name && !declaration.id.name.startsWith("_") && !variableExceptions.includes(declaration.id.name)) {
-              context.report({
-                node: declaration,
-                message: `Variables defined within a method should start with "_" ({${declaration.id.name}})`,
-              });
-            }
-          });
-
-          break;
-        }
-
-        // BlockStatement and Program nodes contain lists of statements \
-        //   (node.body), so we check each statement
-        case "BlockStatement":
-        case "Program": {
-          node.body.forEach(checkDeclaration);
-
-          break;
+    return {
+      VariableDeclaration(node) {
+        // Constant names are validated by the const rule.
+        if (node.kind === "const" || !isLocalDeclaration(node)) {
+          return;
         }
 
-        // IfStatement nodes have a consequent (then), and an \
-        //   optional alternate (else) to be checked
-        case "IfStatement": {
-          checkDeclaration(node.consequent);
-
-          if (node.alternate) {
-            checkDeclaration(node.alternate);
+        for (const declaration of node.declarations) {
+          if (declaration.id.type !== "Identifier") {
+            continue;
           }
 
-          break;
-        }
-
-        // Loops nodes contain a body with statements to be checked
-        case "ForStatement":
-        case "WhileStatement":
-        case "DoWhileStatement":
-        case "ForInStatement":
-        case "ForOfStatement": {
-          if (node.body) {
-            checkDeclaration(node.body);
+          if (
+            !declaration.id.name.startsWith("_") &&
+            !variableExceptions.includes(declaration.id.name)
+          ) {
+            context.report({
+              node: declaration.id,
+              message: `Local variables should start with "_" ({${declaration.id.name}})`
+            });
           }
-
-          // Check the loop condition itself
-          checkDeclaration(node.left);
-
-          break;
-        }
-
-        // SwitchStatement nodes contain an array of SwitchCase nodes that \
-        //   represent each case in the switch statement
-        case "SwitchStatement": {
-          node.cases.forEach(checkDeclaration);
-
-          break;
-        }
-
-        // SwitchCase nodes contain a consequent which is an array of \
-        //   Statements to be checked
-        case "SwitchCase": {
-          node.consequent.forEach(checkDeclaration);
-
-          break;
-        }
-
-        default: {
-          break;
-        }
-      }
-    }
-
-    return {
-      // For each property in an object, if it's a function / arrow function, \
-      //   check its body (usefull for Vue.js components, in which methods and \
-      //   computed are defined as properties of a parent object)
-      Property(node) {
-        if (node.value.type === "FunctionExpression" ||
-            node.value.type === "ArrowFunctionExpression") {
-          checkDeclaration(node);
-        }
-      },
-
-      MethodDefinition(node) {
-        checkDeclaration(node.value.body);
-      },
-
-      ArrowFunctionExpression(node) {
-        if (node.body.type === "BlockStatement") {
-          checkDeclaration(node.body);
-        }
-      },
-
-      FunctionExpression(node) {
-        if (node.body.type === "BlockStatement") {
-          checkDeclaration(node.body);
         }
       }
     };