eslint-plugin-crisp 1.7.9 → 1.7.11

package/README.md

@@ -230,6 +230,7 @@ Each item has emojis denoting:
 | [crisp/vue-header-check](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/vue-header-check.js) | Ensures `script`, `template` and `style` tags start with corresponding comment block |  | 🟢 |
 | [crisp/vue-html-indent](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/vue-html-indent.js) | Enforces consistent indentation in `template` (supports for Pug) |  | 🟢 |
 | [crisp/vue-html-quotes](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/vue-html-quotes.js) | Enforces HTML attributes to be enclosed with double quotes |  | 🟢 |
+| [crisp/vue-methods-separator](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/vue-methods-separator.js) | Requires method section comments to be ordered as actions, helpers, then event listeners |  | 🟢 |
 | [crisp/vue-no-component-class-shorthand](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/vue-no-component-class-shorthand.js) | Disallows Pug class shorthand on Vue components |  | 🟢 |
 | [crisp/vue-no-mixed-class](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/vue-no-mixed-class.js) | Disallows using both `class` and `:class` on the same element |  | 🟢 |
 | [crisp/vue-no-name-option](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/vue-no-name-option.js) | Disallows explicit component names in Vue single-file components |  | 🟢 |

package/package.json

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

package/rules/logger-arguments.js

@@ -94,6 +94,14 @@ function isReference(node) {
   );
 }
 
+// Checks an empty object or array literal (eg. `{}` or `[]`)
+function isEmptyLiteral(node) {
+  return (
+    (node.type === "ObjectExpression" && node.properties.length === 0) ||
+    (node.type === "ArrayExpression" && node.elements.length === 0)
+  );
+}
+
 // Checks a fallback expression like `value || "none"` or `value ?? other`
 function isFallback(node) {
   node = unwrapTransparentExpression(node);
@@ -111,6 +119,7 @@ function isFallback(node) {
 
     return (
       operand.type === "Literal" ||
+      isEmptyLiteral(operand) ||
       isReference(operand) ||
       isFallback(operand)
     );
@@ -151,6 +160,61 @@ function isReferenceObject(node) {
   });
 }
 
+// Checks a node is a `logger.levels.<level>` member expression
+function isLevelsReference(node) {
+  node = unwrapTransparentExpression(node);
+
+  return (
+    Boolean(node) &&
+    node.type === "MemberExpression" &&
+    node.object.type === "MemberExpression" &&
+    getPropertyName(node.object) === "levels" &&
+    node.object.object.type === "MemberExpression" &&
+    getPropertyName(node.object.object) === "logger"
+  );
+}
+
+// Checks a condition tests a logger level (eg. `logger.levels.error === true && x`)
+function isLevelCheck(node) {
+  node = unwrapTransparentExpression(node);
+
+  if (!node) {
+    return false;
+  }
+
+  if (node.type === "LogicalExpression" && node.operator === "&&") {
+    return isLevelCheck(node.left) || isLevelCheck(node.right);
+  }
+
+  if (
+    node.type === "BinaryExpression" &&
+    (node.operator === "===" || node.operator === "==")
+  ) {
+    return isLevelsReference(node.left) || isLevelsReference(node.right);
+  }
+
+  return isLevelsReference(node);
+}
+
+// Checks a node is inside the consequent of a logger level guard
+function isGuarded(ancestors, node) {
+  const chain = [...ancestors, node];
+
+  for (let index = chain.length - 2; index >= 0; index--) {
+    const ancestor = chain[index];
+
+    if (
+      ancestor.type === "IfStatement" &&
+      chain[index + 1] === ancestor.consequent &&
+      isLevelCheck(ancestor.test)
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 export default {
   meta: {
     type: "suggestion",
@@ -177,6 +241,11 @@ export default {
           return;
         }
 
+        // Guarded by a log level check: computed values are allowed
+        if (isGuarded(sourceCode.getAncestors(node), node)) {
+          return;
+        }
+
         const [message, ...values] = node.arguments;
 
         if (

package/rules/vue-methods-separator.js

@@ -1,65 +1,121 @@
+const SEPARATORS = [
+  "--> ACTIONS <--",
+  "--> HELPERS <--",
+  "--> EVENT LISTENERS <--"
+];
+
+const SEPARATOR_ORDER = new Map(
+  SEPARATORS.map((separator, index) => [separator, index])
+);
+const SEPARATOR_LIKE_PATTERN = /^--> .+ <--$/;
+
 export default {
   meta: {
     type: "suggestion",
     docs: {
-      description: "enforce at least one separator comment in Vue methods block",
+      description:
+        "enforce separator comments and their order in Vue methods block",
       category: "Stylistic Issues",
       recommended: false
     },
     fixable: null,
-    schema: []
+    schema: [],
+    messages: {
+      duplicateSeparator:
+        "Duplicate methods separator comment '// {{separator}}'.",
+      invalidSeparator:
+        "Invalid separator comment. Must be '// --> ACTIONS <--', " +
+        "'// --> HELPERS <--', or '// --> EVENT LISTENERS <--'.",
+      missingSeparator:
+        "Methods block must contain at least one separator comment: " +
+        "'// --> ACTIONS <--', '// --> HELPERS <--', " +
+        "or '// --> EVENT LISTENERS <--'.",
+      unorderedSeparator:
+        "Methods separator comments must be ordered: '// --> ACTIONS <--', " +
+        "then '// --> HELPERS <--', then '// --> EVENT LISTENERS <--'."
+    }
   },
 
   create(context) {
-    const SEPARATOR_PATTERN = /^--> (ACTIONS|HELPERS|EVENT LISTENERS) <--$/;
-    const SEPARATOR_LIKE_PATTERN = /^--> .+ <--$/;
+    const sourceCode = context.sourceCode;
 
-    return {
-      'ExportDefaultDeclaration Property[key.name="methods"]'(node) {
-        const properties = node.value.properties;
+    function checkMethods(node) {
+      const properties = node.value.properties;
+
+      if (!properties || properties.length === 0) {
+        return;
+      }
+
+      const comments = sourceCode.getCommentsInside(node.value).filter(
+        (comment) => {
+          return !properties.some((property) => {
+            return (
+              comment.range[0] >= property.range[0] &&
+              comment.range[1] <= property.range[1]
+            );
+          });
+        }
+      );
+      const seenSeparators = new Set();
+      let lastSeparatorOrder = -1;
+      let separatorCount = 0;
 
-        if (!properties || properties.length === 0) {
+      comments.forEach((comment) => {
+        if (comment.type !== "Line") {
           return;
         }
 
-        const sourceCode = context.sourceCode;
-        const comments = sourceCode.getCommentsInside(node);
+        const separator = comment.value.trim();
+        const separatorOrder = SEPARATOR_ORDER.get(separator);
 
-        const hasSeparator = comments.some((comment) => {
-          return (
-            comment.type === "Line" &&
-            SEPARATOR_PATTERN.test(comment.value.trim())
-          );
-        });
+        if (separatorOrder === undefined) {
+          if (SEPARATOR_LIKE_PATTERN.test(separator)) {
+            context.report({
+              node: comment,
+              messageId: "invalidSeparator"
+            });
+          }
+
+          return;
+        }
+
+        separatorCount++;
 
-        if (!hasSeparator) {
+        if (seenSeparators.has(separator)) {
           context.report({
-            node,
-            message:
-              "Methods block must contain at least one separator comment: " +
-              "'// --> ACTIONS <--', '// --> HELPERS <--', " +
-              "or '// --> EVENT LISTENERS <--'."
+            node: comment,
+            messageId: "duplicateSeparator",
+            data: { separator }
           });
+
+          return;
         }
 
-        comments.forEach((comment) => {
-          if (comment.type === "Line") {
-            const trimmed = comment.value.trim();
-
-            if (
-              SEPARATOR_LIKE_PATTERN.test(trimmed) &&
-              !SEPARATOR_PATTERN.test(trimmed)
-            ) {
-              context.report({
-                node: comment,
-                message:
-                  "Invalid separator comment. Must be '// --> ACTIONS <--', " +
-                  "'// --> HELPERS <--', or '// --> EVENT LISTENERS <--'."
-              });
-            }
-          }
+        seenSeparators.add(separator);
+
+        if (separatorOrder < lastSeparatorOrder) {
+          context.report({
+            node: comment,
+            messageId: "unorderedSeparator"
+          });
+        } else {
+          lastSeparatorOrder = separatorOrder;
+        }
+      });
+
+      if (separatorCount === 0) {
+        context.report({
+          node,
+          messageId: "missingSeparator"
         });
       }
+    }
+
+    return {
+      'ExportDefaultDeclaration > ObjectExpression > Property[key.name="methods"]':
+        checkMethods,
+      'ExportDefaultDeclaration > CallExpression[callee.name="defineComponent"] > ObjectExpression > Property[key.name="methods"]':
+        checkMethods
     };
   }
 };

package/tests/rules/logger-arguments.test.js

@@ -19,6 +19,12 @@ ruleTester.run("logger-arguments", rule, {
     "App.logger.debug(\"Loaded value: %s\", this.value ?? \"none\");",
     "App.logger.debug(\"Loaded value: %s\", first || second || \"none\");",
     "App.logger.debug(\"Loaded value: %s\", { user: userId || \"none\" });",
+    "if (App.logger.levels.error === true) { App.logger.error(\"Purge failed: %s\", buckets.join(\", \"), error); }",
+    "if (App.logger.levels.warn === true) { App.logger.warn(fn_log_format()); }",
+    "if (App.logger.levels.error === true && other) { if (x) { App.logger.error(\"Slow: %s\", a + b); } }",
+    "if (this._app.logger.levels.debug) { this._app.logger.debug(\"Count: %s\", list.length + 1); }",
+    "App.logger.error(\"Failed\", { params: (request.params || {}) });",
+    "App.logger.error(\"Failed: %s\", list || []);",
     "App.logger.warn(\"Shutting down\", { bufferedCount });",
     "App.logger.warn(\"Shutting down\", { count: this.count, ...meta });",
     "App.logger.warn(\"Shutting down\", { nested: { bufferedCount } }, logMeta);",
@@ -123,6 +129,22 @@ ruleTester.run("logger-arguments", rule, {
         }
       ]
     },
+    {
+      code: "if (App.logger.levels.error === true) {} else { App.logger.error(\"Purge: %s\", buckets.join(\", \")); }",
+      errors: [
+        {
+          messageId: "reference"
+        }
+      ]
+    },
+    {
+      code: "if (enabled) { App.logger.error(\"Purge: %s\", buckets.join(\", \")); }",
+      errors: [
+        {
+          messageId: "reference"
+        }
+      ]
+    },
     {
       code: "App.logger.debug(\"Retry count: %s\", 3);",
       errors: [

package/tests/rules/vue-methods-separator.test.js

@@ -1,7 +1,7 @@
 import rule from "../../rules/vue-methods-separator.js";
-import createRuleTester from "../rule-tester.js";
+import { createVueRuleTester } from "../rule-tester.js";
 
-const ruleTester = createRuleTester();
+const ruleTester = createVueRuleTester();
 
 ruleTester.run("vue-methods-separator", rule, {
   valid: [
@@ -17,6 +17,98 @@ ruleTester.run("vue-methods-separator", rule, {
           }
         };
       `
+    },
+    {
+      code: `
+        export default {
+          methods: {
+            // --> HELPERS <--
+            format() {}
+          }
+        };
+      `
+    },
+    {
+      code: `
+        export default {
+          methods: {
+            // --> EVENT LISTENERS <--
+            onSave() {}
+          }
+        };
+      `
+    },
+    {
+      code: `
+        export default {
+          methods: {
+            // --> ACTIONS <--
+            save() {},
+            // --> EVENT LISTENERS <--
+            onSave() {}
+          }
+        };
+      `
+    },
+    {
+      code: `
+        export default defineComponent({
+          methods: {
+            // --> ACTIONS <--
+            save() {},
+            // --> HELPERS <--
+            format() {},
+            // --> EVENT LISTENERS <--
+            onSave() {}
+          }
+        });
+      `
+    },
+    {
+      code: `
+        export default {
+          options: {
+            methods: {
+              save() {}
+            }
+          }
+        };
+      `
+    },
+    {
+      code: `
+        export default {
+          methods: {
+            // --> ACTIONS <--
+            save() {
+              // --> EVENT LISTENERS <--
+              const status = "saved";
+
+              return status;
+            },
+            // --> HELPERS <--
+            format() {}
+          }
+        };
+      `
+    },
+    {
+      filename: "Component.vue",
+      code: `
+        <template><div /></template>
+        <script>
+        export default defineComponent({
+          methods: {
+            // --> ACTIONS <--
+            save() {},
+            // --> HELPERS <--
+            format() {},
+            // --> EVENT LISTENERS <--
+            onSave() {}
+          }
+        });
+        </script>
+      `
     }
   ],
 
@@ -25,10 +117,7 @@ ruleTester.run("vue-methods-separator", rule, {
       code: "export default { methods: { save() {} } };",
       errors: [
         {
-          message:
-            "Methods block must contain at least one separator comment: " +
-            "'// --> ACTIONS <--', '// --> HELPERS <--', " +
-            "or '// --> EVENT LISTENERS <--'."
+          messageId: "missingSeparator"
         }
       ]
     },
@@ -45,9 +134,95 @@ ruleTester.run("vue-methods-separator", rule, {
       `,
       errors: [
         {
-          message:
-            "Invalid separator comment. Must be '// --> ACTIONS <--', " +
-            "'// --> HELPERS <--', or '// --> EVENT LISTENERS <--'."
+          messageId: "invalidSeparator"
+        }
+      ]
+    },
+    {
+      code: `
+        export default {
+          methods: {
+            // --> HELPERS <--
+            format() {},
+            // --> ACTIONS <--
+            save() {}
+          }
+        };
+      `,
+      errors: [
+        {
+          messageId: "unorderedSeparator"
+        }
+      ]
+    },
+    {
+      code: `
+        export default {
+          methods: {
+            // --> ACTIONS <--
+            save() {},
+            // --> ACTIONS <--
+            publish() {}
+          }
+        };
+      `,
+      errors: [
+        {
+          messageId: "duplicateSeparator",
+          data: { separator: "--> ACTIONS <--" }
+        }
+      ]
+    },
+    {
+      code: `
+        export default defineComponent({
+          methods: {
+            // --> EVENT LISTENERS <--
+            onSave() {},
+            // --> HELPERS <--
+            format() {}
+          }
+        });
+      `,
+      errors: [
+        {
+          messageId: "unorderedSeparator"
+        }
+      ]
+    },
+    {
+      code: `
+        export default {
+          methods: {
+            save() {
+              // --> ACTIONS <--
+            }
+          }
+        };
+      `,
+      errors: [
+        {
+          messageId: "missingSeparator"
+        }
+      ]
+    },
+    {
+      filename: "Component.vue",
+      code: `
+        <script>
+        export default defineComponent({
+          methods: {
+            // --> EVENT LISTENERS <--
+            onSave() {},
+            // --> ACTIONS <--
+            save() {}
+          }
+        });
+        </script>
+      `,
+      errors: [
+        {
+          messageId: "unorderedSeparator"
         }
       ]
     }