eslint-plugin-crisp 1.6.2 → 1.6.4

package/README.md

@@ -125,9 +125,10 @@ Each item has emojis denoting:
 | [crisp/constructor-variables](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/constructor-variables.js) | Ensures all class properties in the constructor start with `_` | 🟠 |
 | [crisp/enforce-optional](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/enforce-optional.js) | Enforces use of optional chaining | 🟠 | 🟢 | 🟣 |
 | [crisp/header-check](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/header-check.js) | Enforces files to start with Crisp header | 🟠 | 🟢 | 🟣 |
-| [crisp/header-comments-check](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/header-comments-check.js) | Enforces different comment blocks before different groups (imports, constants, instances and exports) | 🟠 | 🟢 | 🟣 |
+| [crisp/header-comments-check](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/header-comments-check.js) | Enforces different comment blocks before different groups (imports, constants and instances) | 🟠 | 🟢 | 🟣 |
 | [crisp/import-group-comment](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/import-group-comment.js) | Ensures `import` statements are preceded by a comment stating their type |  | 🟢 | 🟣 |
 | [crisp/import-group-order](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/import-group-order.js) | Ensures `import` statements are correctly ordered |  | 🟢 | 🟣 |
+| [crisp/logger-arguments](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/logger-arguments.js) | Requires static logger messages and reference-only interpolation arguments | 🟠 | 🟢 | 🟣 |
 | [crisp/methods-naming](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/methods-naming.js) | Ensures methods are named according to their access (`public`, `private`, `protected`) | 🟠 | 🟢 | 🟣 |
 | [crisp/methods-ordering](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/methods-ordering.js) | Ensures methods order according to their access: `public` then `protected` then `private` | 🟠 | 🟢 | 🟣 |
 | [crisp/multiline-comment-end-backslash](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/multiline-comment-end-backslash.js) | Enforces multiline comments to end with a backslash | 🟠 | 🟢 | 🟣 |

package/index.js

@@ -24,6 +24,7 @@ import ruleJsdocEnforceClassdesc from "./rules/jsdoc-enforce-classdesc.js";
 import ruleJsdocNoParamReturn from "./rules/jsdoc-no-param-return.js";
 import ruleJsdocRequireDescriptionUppercase from "./rules/jsdoc-require-description-uppercase.js";
 import ruleJsdocDescriptionLength from "./rules/jsdoc-description-length.js";
+import ruleLoggerArguments from "./rules/logger-arguments.js";
 import ruleMethodsNaming from "./rules/methods-naming.js";
 import ruleMethodsOrdering from "./rules/methods-ordering.js";
 import ruleMultilineCommentEndBackslash from "./rules/multiline-comment-end-backslash.js";
@@ -101,6 +102,7 @@ const plugin = {
     "jsdoc-no-param-return": ruleJsdocNoParamReturn,
     "jsdoc-require-description-uppercase": ruleJsdocRequireDescriptionUppercase,
     "jsdoc-description-length": ruleJsdocDescriptionLength,
+    "logger-arguments": ruleLoggerArguments,
     "methods-naming": ruleMethodsNaming,
     "methods-ordering": ruleMethodsOrdering,
     "multiline-comment-end-backslash": ruleMultilineCommentEndBackslash,

package/package.json

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

package/recommended-ts.js

@@ -161,6 +161,7 @@ export default function configRecommendedTS(pluginCrisp) {
         "crisp/header-comments-check": "error",
         "crisp/import-group-comment": "error",
         "crisp/import-group-order": "error",
+        "crisp/logger-arguments": "error",
         "crisp/methods-naming": "error",
         "crisp/methods-ordering": "error",
         "crisp/multiline-comment-end-backslash": "error",

package/recommended.js

@@ -166,6 +166,7 @@ export default function configRecommended(pluginCrisp) {
         "crisp/enforce-optional": "error",
         "crisp/header-check": "error",
         "crisp/header-comments-check": "error",
+        "crisp/logger-arguments": "error",
         "crisp/methods-naming": "error",
         "crisp/methods-ordering": "error",
         "crisp/multiline-comment-end-backslash": "error",

package/rules/logger-arguments.js

@@ -0,0 +1,149 @@
+const LOGGER_METHODS = new Set([
+  "debug",
+  "error",
+  "fatal",
+  "info",
+  "log",
+  "trace",
+  "warn"
+]);
+
+function getPropertyName(node) {
+  if (!node || node.type !== "MemberExpression") {
+    return null;
+  }
+
+  if (!node.computed && node.property.type === "Identifier") {
+    return node.property.name;
+  }
+
+  if (
+    node.computed &&
+    node.property.type === "Literal" &&
+    typeof node.property.value === "string"
+  ) {
+    return node.property.value;
+  }
+
+  return null;
+}
+
+function isLoggerCall(node) {
+  if (
+    node.callee.type !== "MemberExpression" ||
+    !LOGGER_METHODS.has(getPropertyName(node.callee))
+  ) {
+    return false;
+  }
+
+  return (
+    node.callee.object.type === "MemberExpression" &&
+    getPropertyName(node.callee.object) === "logger"
+  );
+}
+
+function unwrapTransparentExpression(node) {
+  while (
+    node &&
+    (
+      node.type === "ChainExpression" ||
+      node.type === "TSAsExpression" ||
+      node.type === "TSInstantiationExpression" ||
+      node.type === "TSNonNullExpression" ||
+      node.type === "TSTypeAssertion"
+    )
+  ) {
+    node = node.expression;
+  }
+
+  return node;
+}
+
+function isReference(node) {
+  node = unwrapTransparentExpression(node);
+
+  if (!node) {
+    return false;
+  }
+
+  if (
+    node.type === "Identifier" ||
+    node.type === "MetaProperty" ||
+    node.type === "Super" ||
+    node.type === "ThisExpression"
+  ) {
+    return true;
+  }
+
+  if (node.type !== "MemberExpression" || !isReference(node.object)) {
+    return false;
+  }
+
+  if (!node.computed) {
+    return (
+      node.property.type === "Identifier" ||
+      node.property.type === "PrivateIdentifier"
+    );
+  }
+
+  const property = unwrapTransparentExpression(node.property);
+
+  return (
+    property.type === "Literal" ||
+    isReference(property)
+  );
+}
+
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce static logger messages and reference arguments",
+      category: "Best Practices",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      message:
+        "Logger messages must be single-line, double-quoted string literals.",
+      reference:
+        "Logger interpolation arguments must be references, not computed expressions."
+    }
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+
+    return {
+      CallExpression(node) {
+        if (!isLoggerCall(node)) {
+          return;
+        }
+
+        const [message, ...values] = node.arguments;
+
+        if (
+          !message ||
+          message.type !== "Literal" ||
+          typeof message.value !== "string" ||
+          message.loc.start.line !== message.loc.end.line ||
+          !sourceCode.getText(message).startsWith("\"")
+        ) {
+          context.report({
+            node: message || node,
+            messageId: "message"
+          });
+        }
+
+        for (const value of values) {
+          if (!isReference(value)) {
+            context.report({
+              node: value,
+              messageId: "reference"
+            });
+          }
+        }
+      }
+    };
+  }
+};

package/rules/one-space-after-operator.js

@@ -6,7 +6,7 @@ export default {
       category: "Stylistic Issues",
       recommended: false,
     },
-    fixable: "whitespace", // or "code" or "whitespace"
+    fixable: "code",
     schema: [
       {
         type: "object",
@@ -27,7 +27,7 @@ export default {
     const config = context.options[0] || {};
     const checkColon = config.checkColon !== false;
 
-    const checkSpacing = (operatorToken) => {
+    const checkSpacing = (operatorToken, valueNode, indentationNode) => {
       if (!operatorToken) {
         return;
       }
@@ -46,6 +46,10 @@ export default {
       );
       const hasSpaceBefore = /[ \t]$/.test(beforeText);
       const hasOneSpaceAfter = afterText === " ";
+      const hasLineBreakAfter = (
+        /^[\s]*$/.test(afterText) &&
+        /[\r\n]/.test(afterText)
+      );
 
       if (!hasSpaceBefore || !hasOneSpaceAfter) {
         context.report({
@@ -62,11 +66,37 @@ export default {
               ));
             }
 
-            if (!hasOneSpaceAfter && /^[ \t]*$/.test(afterText)) {
-              fixes.push(fixer.replaceTextRange(
-                [operatorToken.range[1], tokenAfter.range[0]],
-                " "
-              ));
+            if (!hasOneSpaceAfter) {
+              if (/^[ \t]*$/.test(afterText)) {
+                fixes.push(fixer.replaceTextRange(
+                  [operatorToken.range[1], tokenAfter.range[0]],
+                  " "
+                ));
+              } else if (hasLineBreakAfter && valueNode) {
+                const firstValueToken = sourceCode.getTokenAfter(operatorToken);
+
+                if (firstValueToken.value === "(") {
+                  fixes.push(fixer.replaceTextRange(
+                    [operatorToken.range[1], tokenAfter.range[0]],
+                    " "
+                  ));
+                } else {
+                  const indentation = " ".repeat(
+                    indentationNode.loc.start.column
+                  );
+
+                  fixes.push(
+                    fixer.replaceTextRange(
+                      [operatorToken.range[1], tokenAfter.range[0]],
+                      ` (${afterText}`
+                    ),
+                    fixer.insertTextAfter(
+                      valueNode,
+                      `\n${indentation})`
+                    )
+                  );
+                }
+              }
             }
 
             return fixes.length ? fixes : null;
@@ -83,7 +113,7 @@ export default {
           token => token.value === node.operator
         );
 
-        checkSpacing(operatorToken);
+        checkSpacing(operatorToken, node.right, node);
       },
       VariableDeclarator(node) {
         if (node.init) {
@@ -93,7 +123,7 @@ export default {
             token => token.value === "="
           );
 
-          checkSpacing(operatorToken);
+          checkSpacing(operatorToken, node.init, node.parent);
         }
       },
 

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

@@ -0,0 +1,123 @@
+import rule from "../../rules/logger-arguments.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("logger-arguments", rule, {
+  valid: [
+    "App.logger.info(\"Application ready.\");",
+    "App.logger.debug(\"Found %s jobs at %s/%s\", cronJobs.length, JOBS_PATH, cronName);",
+    "app.logger.warn(\"Request failed\", error);",
+    "this._app.logger.error(\"Request failed: %s\", this.error.message);",
+    "App[\"logger\"][\"info\"](\"Loaded value: %s\", values[index]);",
+    `App.logger.info(
+  "Loaded value: %s",
+  value
+);`,
+    "App.logger.info(\"This intentionally long logger message may exceed the usual source line length when necessary.\");",
+    "App.logger.child({ namespace: \"worker\" });",
+    "console.info(`Unrelated logger calls are ignored: ${value}`);"
+  ],
+
+  invalid: [
+    {
+      code: "App.logger.info('Application ready.');",
+      errors: [
+        {
+          messageId: "message"
+        }
+      ]
+    },
+    {
+      code: "App.logger.info(`Application ready.`);",
+      errors: [
+        {
+          messageId: "message"
+        }
+      ]
+    },
+    {
+      code: "App.logger.info(`Loaded value: ${value}`);",
+      errors: [
+        {
+          messageId: "message"
+        }
+      ]
+    },
+    {
+      code: "App.logger.info(\"Loaded \" + value);",
+      errors: [
+        {
+          messageId: "message"
+        }
+      ]
+    },
+    {
+      code: "App.logger.info(message);",
+      errors: [
+        {
+          messageId: "message"
+        }
+      ]
+    },
+    {
+      code: "App.logger.info();",
+      errors: [
+        {
+          messageId: "message"
+        }
+      ]
+    },
+    {
+      code: "App.logger.debug(\"Loaded values: %s\", values.join(\", \"));",
+      errors: [
+        {
+          messageId: "reference"
+        }
+      ]
+    },
+    {
+      code: "App.logger.debug(\"Loaded value: %s\", value || \"default\");",
+      errors: [
+        {
+          messageId: "reference"
+        }
+      ]
+    },
+    {
+      code: "App.logger.debug(\"Loaded value: %s\", JSON.stringify(value));",
+      errors: [
+        {
+          messageId: "reference"
+        }
+      ]
+    },
+    {
+      code: "App.logger.debug(\"Loaded value: %s\", { value });",
+      errors: [
+        {
+          messageId: "reference"
+        }
+      ]
+    },
+    {
+      code: "App.logger.debug(\"Retry count: %s\", 3);",
+      errors: [
+        {
+          messageId: "reference"
+        }
+      ]
+    },
+    {
+      code: "App.logger.debug(\"Values: %s / %s\", values.join(\", \"), fallback || \"none\");",
+      errors: [
+        {
+          messageId: "reference"
+        },
+        {
+          messageId: "reference"
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/one-space-after-operator.test.js

@@ -68,6 +68,54 @@ ruleTester.run("one-space-after-operator", rule, {
         }
       ]
     },
+    {
+      code: `let value =
+  first ||
+  second;`,
+      output: `let value = (
+  first ||
+  second
+);`,
+      errors: [
+        {
+          message: "There should be at least one space before and exactly one space after '='"
+        }
+      ]
+    },
+    {
+      code: `function update() {
+  value +=
+    first *
+    second;
+}`,
+      output: `function update() {
+  value += (
+    first *
+    second
+  );
+}`,
+      errors: [
+        {
+          message: "There should be at least one space before and exactly one space after '+='"
+        }
+      ]
+    },
+    {
+      code: `let value =
+  (
+    first ||
+    second
+  );`,
+      output: `let value = (
+    first ||
+    second
+  );`,
+      errors: [
+        {
+          message: "There should be at least one space before and exactly one space after '='"
+        }
+      ]
+    },
     {
       code: "const object = { key:  value };",
       output: "const object = { key : value };",