eslint-plugin-crisp 1.4.9 → 1.4.11

package/README.md

@@ -115,6 +115,7 @@ Each item has emojis denoting:
 | Name | Description | 🟠 | 🟢 | 🟣 |
 | :- | :- | :- | :- | :- |
 | [crisp/align-comments](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/align-comments.js) | Enforces alignment of comments compared to the previous line (the `indent` rule doesn't check this case) | 🟠 | 🟢 | 🟣 |
+| [crisp/consecutive-line-comments](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/consecutive-line-comments.js) | Enforces consecutive single-line comments to form a single multi-line continuation block | 🟠 | 🟢 | 🟣 |
 | [crisp/align-consecutive-class-assignements](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/align-consecutive-class-assignements.js) | Enforces alignment of consecutive assignment statements in a class constructor | 🟠 |
 | [crisp/align-one-var](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/align-one-var.js) | Enforces alignment of variables in 'one-var' statements | 🟠 |
 | [crisp/align-requires](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/align-requires.js) | Enforces alignment of require statements | 🟠 |

package/index.js

@@ -6,6 +6,7 @@ import ruleAlignComments from "./rules/align-comments.js";
 import ruleAlignConsecutiveClassAssignements from "./rules/align-consecutive-class-assignements.js";
 import ruleAlignOneVar from "./rules/align-one-var.js";
 import ruleAlignRequires from "./rules/align-requires.js";
+import ruleConsecutiveLineComments from "./rules/consecutive-line-comments.js";
 import ruleConst from "./rules/const.js";
 import ruleConstructorVariables from "./rules/constructor-variables.js";
 import ruleEnforceOptional from "./rules/enforce-optional.js";
@@ -40,6 +41,7 @@ import ruleVariableNames from "./rules/variable-names.js";
 import ruleVueAttributeComma from "./rules/vue-attribute-comma.js";
 import ruleVueAttributeLinebreak from "./rules/vue-attribute-linebreak.js";
 import ruleVueComputedOrder from "./rules/vue-computed-order.js";
+import ruleVueDataComment from "./rules/vue-data-comment.js";
 import ruleVueEmitsOrder from "./rules/vue-emits-order.js";
 import ruleVueHeaderCheck from "./rules/vue-header-check.js";
 import ruleVueHtmlIndent from "./rules/vue-html-indent.js";
@@ -70,6 +72,7 @@ const plugin = {
     "align-consecutive-class-assignements": ruleAlignConsecutiveClassAssignements,
     "align-one-var": ruleAlignOneVar,
     "align-requires": ruleAlignRequires,
+    "consecutive-line-comments": ruleConsecutiveLineComments,
     "const": ruleConst,
     "constructor-variables": ruleConstructorVariables,
     "enforce-optional": ruleEnforceOptional,
@@ -104,6 +107,7 @@ const plugin = {
     "vue-attribute-comma": ruleVueAttributeComma,
     "vue-attribute-linebreak": ruleVueAttributeLinebreak,
     "vue-computed-order": ruleVueComputedOrder,
+    "vue-data-comment": ruleVueDataComment,
     "vue-emits-order": ruleVueEmitsOrder,
     "vue-header-check": ruleVueHeaderCheck,
     "vue-html-indent": ruleVueHtmlIndent,

package/package.json

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

package/recommended-ts.js

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

package/recommended-vue.js

@@ -162,6 +162,7 @@ export default function configRecommendedVue(pluginCrisp) {
 
         // Crisp JS rules
         "crisp/align-comments": "error",
+        "crisp/consecutive-line-comments": "error",
         "crisp/enforce-optional": "error",
         "crisp/header-check": "error",
         "crisp/header-comments-check": "error",
@@ -374,6 +375,7 @@ export default function configRecommendedVue(pluginCrisp) {
         "crisp/vue-attribute-comma": "error",
         "crisp/vue-attribute-linebreak": "error",
         "crisp/vue-computed-order": "error",
+        "crisp/vue-data-comment": "error",
         "crisp/vue-emits-order": "error",
         "crisp/vue-header-check": "error",
         "crisp/vue-html-indent": "error",

package/recommended.js

@@ -156,6 +156,7 @@ export default function configRecommended(pluginCrisp) {
 
         // Crisp JS rules
         "crisp/align-comments": "error",
+        "crisp/consecutive-line-comments": "error",
         "crisp/align-consecutive-class-assignements": "error",
         "crisp/align-one-var": "error",
         "crisp/align-requires": "error",

package/rules/consecutive-line-comments.js

@@ -0,0 +1,250 @@
+const DIRECTIVE_REGEX = /^(eslint|ts-|@ts|prettier-|global |globals |istanbul|c8 |v8 |jshint|jslint)/;
+
+// A short capitalized label followed by a colon (e.g. 'Notice:', 'Important:',
+// 'Source:') introduces a new logical comment, so the previous comment does not
+// need to be merged into a continuation block with it. The label is kept short
+// (up to ~40 chars) to avoid matching a regular sentence that contains a colon
+const BOUNDARY_REGEX = /^[A-Z][^:]{0,39}:/;
+
+function getCore(comment) {
+  // Strip the trailing continuation backslash and surrounding whitespace
+  return comment.value.replace(/\\\s*$/, "").trim();
+}
+
+function isDirective(core) {
+  return DIRECTIVE_REGEX.test(core);
+}
+
+function isBoundary(core) {
+  return BOUNDARY_REGEX.test(core);
+}
+
+function isContinuationLine(comment) {
+  // Continuation lines use at least three spaces after '//'
+  return /^ {3,}/.test(comment.value);
+}
+
+function isBoundaryComment(comment) {
+  // Labels such as 'Notice:' only split groups on first lines, not mid-block
+  // prose like '//   In other words: …'
+  return !isContinuationLine(comment) && isBoundary(getCore(comment));
+}
+
+function endsWithContinuation(comment) {
+  return /\\\s*$/.test(comment.value);
+}
+
+function isBlankSeparatorLine(comment) {
+  // A line that only contains '\' (e.g. '// \' or '//   \') is a visual separator
+  return (
+    comment.type === "Line" &&
+    endsWithContinuation(comment) &&
+    getCore(comment).length === 0
+  );
+}
+
+export default {
+  meta: {
+    type: "layout",
+    docs: {
+      description:
+        "Enforce that consecutive single-line comments are written as a " +
+        "single multi-line continuation block.",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+    fixable: "whitespace",
+    schema: [],
+    messages: {
+      format:
+        "Consecutive single-line comments must form a continuation block: " +
+        "each line ends with '\\' (except the last) and continuation lines " +
+        "are indented with at least three spaces after '//'.",
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+
+    function isStandalone(comment) {
+      const lineText = sourceCode.lines[comment.loc.start.line - 1] || "";
+      const before = lineText.slice(0, comment.loc.start.column);
+
+      return before.trim() === "";
+    }
+
+    function getCanonicalCommentText(comment, index, groupLength) {
+      const core = getCore(comment);
+      const isLast = index === groupLength - 1;
+      const suffix = isLast ? "" : " \\";
+
+      if (index === 0) {
+        return `// ${core}${suffix}`;
+      }
+
+      return `//   ${core}${suffix}`;
+    }
+
+    function commentMatchesCanonical(comment, index, groupLength) {
+      const core = getCore(comment);
+      const isLast = index === groupLength - 1;
+      const line = sourceCode.lines[comment.loc.start.line - 1] || "";
+      const actual = line.slice(comment.loc.start.column);
+
+      if (isBlankSeparatorLine(comment) && index < groupLength - 1) {
+        return /^\/\/\s*\\$/.test(actual);
+      }
+
+      if (index === 0) {
+        const expected = `// ${core}${isLast ? "" : " \\"}`;
+
+        return actual === expected;
+      }
+
+      const match = actual.match(/^\/\/(\s+)(.*)$/);
+
+      if (!match || match[1].length < 3) {
+        return false;
+      }
+
+      let body = match[2];
+
+      if (!isLast) {
+        if (!/\\\s*$/.test(body)) {
+          return false;
+        }
+
+        body = body.replace(/\\\s*$/, "");
+      }
+
+      return body.trim() === core;
+    }
+
+    function checkGroup(group) {
+      if (group.length < 2) {
+        return;
+      }
+
+      const indent = " ".repeat(group[0].loc.start.column);
+
+      const canonicalLines = group.map((comment, index) => {
+        return getCanonicalCommentText(comment, index, group.length);
+      });
+
+      const canonical = canonicalLines.join(`\n${indent}`);
+
+      const allMatch = group.every((comment, index) => {
+        return commentMatchesCanonical(comment, index, group.length);
+      });
+
+      if (allMatch) {
+        return;
+      }
+
+      context.report({
+        loc: {
+          start: group[0].loc.start,
+          end: group[group.length - 1].loc.end,
+        },
+        messageId: "format",
+
+        fix(fixer) {
+          return fixer.replaceTextRange(
+            [group[0].range[0], group[group.length - 1].range[1]],
+            canonical
+          );
+        },
+      });
+    }
+
+    return {
+      Program() {
+        const comments = sourceCode.getAllComments();
+
+        let group = [];
+        let skipDirectiveContinuation = false;
+        let skipColumn = 0;
+        let skipLine = 0;
+
+        const flush = () => {
+          checkGroup(group);
+
+          group = [];
+        };
+
+        for (const comment of comments) {
+          if (
+            skipDirectiveContinuation &&
+            comment.type === "Line" &&
+            isStandalone(comment) &&
+            comment.loc.start.line === skipLine + 1 &&
+            comment.loc.start.column === skipColumn
+          ) {
+            skipLine = comment.loc.start.line;
+
+            if (!endsWithContinuation(comment)) {
+              skipDirectiveContinuation = false;
+            }
+
+            continue;
+          }
+
+          skipDirectiveContinuation = false;
+
+          const core = getCore(comment);
+          const isGroupable =
+            comment.type === "Line" &&
+            isStandalone(comment) &&
+            !isDirective(core) &&
+            (core.length > 0 || isBlankSeparatorLine(comment));
+
+          if (!isGroupable) {
+            flush();
+
+            if (
+              comment.type === "Line" &&
+              isStandalone(comment) &&
+              isDirective(core) &&
+              endsWithContinuation(comment)
+            ) {
+              skipDirectiveContinuation = true;
+              skipColumn = comment.loc.start.column;
+              skipLine = comment.loc.start.line;
+            }
+
+            continue;
+          }
+
+          if (group.length > 0) {
+            const previous = group[group.length - 1];
+            const isConsecutive =
+              comment.loc.start.line === previous.loc.start.line + 1 &&
+              comment.loc.start.column === previous.loc.start.column;
+
+            // A completed block (no trailing '\') must not absorb the next line
+            if (!endsWithContinuation(previous)) {
+              flush();
+            }
+
+            if (group.length > 0) {
+              const last = group[group.length - 1];
+              const stillConsecutive =
+                comment.loc.start.line === last.loc.start.line + 1 &&
+                comment.loc.start.column === last.loc.start.column;
+
+              // A boundary marker (e.g. 'Notice:') always starts a fresh group,
+              // so the previous comment is left untouched
+              if (!stillConsecutive || isBoundaryComment(comment)) {
+                flush();
+              }
+            }
+          }
+
+          group.push(comment);
+        }
+
+        flush();
+      },
+    };
+  },
+};

package/rules/vue-data-comment.js

@@ -0,0 +1,76 @@
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce comment as first line in Vue data() return object",
+      category: "Stylistic Issues",
+      recommended: false
+    },
+    fixable: null,
+    schema: []
+  },
+
+  create(context) {
+    const COMMENT_PATTERN = /^--> (STATE|DATA|ROUTE PARAMS|COMPONENTS) <--$/;
+    const COMMENT_LIKE_PATTERN = /^--> .+ <--$/;
+
+    return {
+      'Property[key.name="data"] > FunctionExpression > BlockStatement > ReturnStatement > ObjectExpression'(node) {
+        const properties = node.properties;
+
+        if (!properties || properties.length === 0) {
+          return;
+        }
+
+        const sourceCode = context.getSourceCode();
+        const comments = sourceCode.getCommentsInside(node);
+
+        if (comments.length === 0) {
+          context.report({
+            node,
+            message:
+              "data() return object must start with a comment: " +
+              "'// --> STATE <--', '// --> DATA <--', " +
+              "'// --> ROUTE PARAMS <--', or '// --> COMPONENTS <--'."
+          });
+
+          return;
+        }
+
+        const firstComment = comments[0];
+
+        if (
+          firstComment.type !== "Line" ||
+          !COMMENT_PATTERN.test(firstComment.value.trim())
+        ) {
+          context.report({
+            node: firstComment,
+            message:
+              "data() return object must start with a comment: " +
+              "'// --> STATE <--', '// --> DATA <--', " +
+              "'// --> ROUTE PARAMS <--', or '// --> COMPONENTS <--'."
+          });
+        }
+
+        comments.forEach((comment) => {
+          if (comment.type === "Line") {
+            const trimmed = comment.value.trim();
+
+            if (
+              COMMENT_LIKE_PATTERN.test(trimmed) &&
+              !COMMENT_PATTERN.test(trimmed)
+            ) {
+              context.report({
+                node: comment,
+                message:
+                  "Invalid comment. Must be '// --> STATE <--', " +
+                  "'// --> DATA <--', '// --> ROUTE PARAMS <--', " +
+                  "or '// --> COMPONENTS <--'."
+              });
+            }
+          }
+        });
+      }
+    };
+  }
+};