eslint-plugin-crisp 1.0.0

package/.github/workflows/build.yml

@@ -0,0 +1,31 @@
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+name: Build and Release
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Install NodeJS
+        uses: actions/setup-node@v1
+        with:
+          node-version: 16.x
+          registry-url: https://registry.npmjs.org
+
+      - name: Verify versions
+        run: node --version && npm --version && node -p process.versions.v8
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Release package
+        run: npm publish --ignore-scripts
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -0,0 +1,2 @@
+# crisp-plugin-eslint
+Custom EsLint Rules for Crisp

package/index.js

@@ -0,0 +1,22 @@
+module.exports = {
+  configs: {
+    recommended: require('./recommended'),
+  },
+  rules: {
+    "jsdoc-match-params": require("./rules/jsdoc-match-params"),
+    "align-one-var": require("./rules/align-one-var"),
+    "no-trailing-spaces": require("./rules/no-trailing-spaces"),
+    "new-line-after-block": require("./rules/new-line-after-block"),
+    "constructor-variables": require("./rules/constructor-variables"),
+    "methods-naming": require("./rules/methods-naming"),
+    "regex-in-constructor": require("./rules/regex-in-constructor"),
+    "one-space-after-operator": require("./rules/one-space-after-operator"),
+    "no-async": require("./rules/no-async"),
+    "const": require("./rules/const"),
+    "two-lines-between-class-members": require("./rules/two-lines-between-class-members"),
+    "align-requires": require("./rules/align-requires"),
+    "ternary-parenthesis": require("./rules/ternary-parenthesis"),
+    "variable-names": require("./rules/variable-names"),
+    "multiline-comment-end-backslash": require("./rules/multiline-comment-end-backslash")
+  }
+};

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "eslint-plugin-crisp",
+  "version": "1.0.0",
+  "description": "Custom EsLint Rules for Crisp",
+  "main": "index.js",
+  "author": "Crisp IM SAS",
+  "license": "MIT",
+  "dependencies": {
+    "doctrine": "3.0.0",
+    "eslint": "8.45.0",
+    "eslint-plugin-jsdoc": "40.3.4"
+  }
+}

package/recommended.js

@@ -0,0 +1,44 @@
+module.exports = {
+  "env": {
+    "es6": true,
+    "node": true
+  },
+  "plugins": [
+    "eslint-plugin-jsdoc"
+  ],
+  "rules": {
+    "indent": "off",
+    "linebreak-style": ["error", "unix"],
+    "quotes": ["error", "double", { "avoidEscape": true, "allowTemplateLiterals": true }],
+    "semi": ["error", "always"],
+    "max-len": ["error", 80],
+    "comma-dangle": ["error", "never"],
+    "crisp/align-one-var": ["error"],
+    "crisp/multiline-comment-end-backslash": "error",
+    "crisp/const": "error",
+    "crisp/regex-in-constructor": ["error"],
+    "crisp/align-requires": "error",
+    "crisp/two-lines-between-class-members": "error",
+    "crisp/no-async": "error",
+    "crisp/methods-naming": "error",
+    "crisp/new-line-after-block": "error",
+    "crisp/one-space-after-operator": "error",
+    "crisp/no-trailing-spaces": "error",
+    "crisp/ternary-parenthesis": "error",
+    "crisp/variable-names": "error",
+    "crisp/jsdoc-match-params": ["error", { "exceptions": ["constructor"] }],
+
+    "crisp/constructor-variables": ["error", {
+      "exceptions": ["client"]
+    }],
+    "jsdoc/require-jsdoc": ["error", {
+      "require": {
+        "FunctionDeclaration": true,
+        "MethodDefinition": true,
+        "ClassDeclaration": true,
+        "ArrowFunctionExpression": false,
+        "FunctionExpression": false
+      }
+    }]
+  }
+}

package/rules/align-one-var.js

@@ -0,0 +1,70 @@
+module.exports = {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "enforce alignment of variables in consecutive 'one-var' statements",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+  },
+  create(context) {
+    const sourceCode = context.getSourceCode();
+
+    return {
+      VariableDeclaration(node) {
+        if (node.declarations.length <= 1) {
+          return;
+        }
+
+        let assignmentOperatorColumn = null;
+        let variableNameColumn = null;
+        let lastDeclarationLine = null;
+
+        for (let i = 0; i < node.declarations.length; i++) {
+          const declaration = node.declarations[i];
+
+          // If the current declaration is on the same line as the last one,
+          // skip it
+          if (lastDeclarationLine === declaration.loc.start.line) {
+            continue;
+          }
+
+          lastDeclarationLine = declaration.loc.start.line;
+
+          const variableNameToken = sourceCode.getFirstToken(declaration);
+          const variableNameColumnCurrent = variableNameToken.loc.start.column;
+
+          if (variableNameColumn === null) {
+            variableNameColumn = variableNameColumnCurrent;
+          } else if (variableNameColumnCurrent !== variableNameColumn) {
+            context.report({
+              node: declaration,
+              message: "Misaligned variable declaration."
+            });
+          }
+
+          if (!declaration.init) {
+            continue; // Skip if there's no assignment
+          }
+
+          const equalsSignToken = sourceCode.getTokenBefore(declaration.init);
+
+          if (equalsSignToken.value !== "=") {
+            continue; // Skip if it's not an assignment
+          }
+
+          const equalsSignColumn = equalsSignToken.loc.start.column;
+
+          if (assignmentOperatorColumn === null) {
+            assignmentOperatorColumn = equalsSignColumn;
+          } else if (equalsSignColumn !== assignmentOperatorColumn) {
+            context.report({
+              node: declaration,
+              message: "Misaligned assignment operator."
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/align-requires.js

@@ -0,0 +1,36 @@
+module.exports = {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "enforce alignment of require statements",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+    fixable: null,  // not auto-fixable
+  },
+  create(context) {
+    return {
+      VariableDeclaration(node) {
+        const declarations = node.declarations;
+
+        // We only check consecutive VariableDeclarator nodes with 'require' init
+        let lastColumn = null;
+
+        for (const declaration of declarations) {
+          if (declaration.init && declaration.init.callee && declaration.init.callee.name === 'require') {
+            if (lastColumn === null) {
+              lastColumn = declaration.loc.start.column;
+            } else if (declaration.loc.start.column !== lastColumn) {
+              context.report({
+                node: declaration,
+                message: "Misaligned require statement.",
+              });
+            }
+          } else {
+            lastColumn = null;  // reset for non-require declarations
+          }
+        }
+      },
+    };
+  },
+};

package/rules/const.js

@@ -0,0 +1,27 @@
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'enforce that consts are uppercase and start with "__"',
+      category: 'Stylistic Issues',
+      recommended: false,
+    },
+    schema: [], // no options
+  },
+  create(context) {
+    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 "__"',
+              });
+            }
+          });
+        }
+      },
+    };
+  },
+};

package/rules/constructor-variables.js

@@ -0,0 +1,40 @@
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure all class properties in the constructor start with '_', except for specified exceptions",
+      category: "Stylistic Issues",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          exceptions: {
+            type: "array",
+            items: { type: "string" },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const exceptions = options.exceptions || [];
+
+    return {
+      "MethodDefinition[kind='constructor'] > FunctionExpression > BlockStatement > ExpressionStatement > AssignmentExpression": function(node) {
+        if(node.left.type === "MemberExpression" && node.left.object.type === "ThisExpression"){
+          const varName = node.left.property.name;
+          if (!varName.startsWith("_") && !exceptions.includes(varName)) {
+            context.report({
+              node,
+              message: "Class properties in the constructor should start with '_', except for specified exceptions",
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/jsdoc-match-params.js

@@ -0,0 +1,56 @@
+const doctrine = require("doctrine");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "enforce JSDoc and function parameter names match",
+      category: "Possible Errors",
+      recommended: true,
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.getSourceCode();
+
+    function getJSDocComment(node) {
+      const commentsBefore = sourceCode.getCommentsBefore(node);
+
+      const jsDocComment = commentsBefore.find(comment =>
+        comment.type === "Block" && comment.value.startsWith("*")
+      );
+
+      if (jsDocComment) {
+        const parsed = doctrine.parse(jsDocComment.value, { unwrap: true });
+        const jsDocParams = parsed.tags.filter(tag => tag.title === "param").map(tag => tag.name);
+        return jsDocParams;
+      }
+
+      return null;
+    }
+
+    function checkParameters(node) {
+      const jsDocParams = getJSDocComment(node);
+
+      if (!jsDocParams) {
+        return;
+      }
+
+      const funcParams = node.value.params.map(param => param.type === "Identifier" ? param.name : param.left.name);
+
+      for (let i = 0; i < jsDocParams.length; i++) {
+        if (jsDocParams[i] !== funcParams[i]) {
+          context.report({
+            node: node,
+            message: `JSDoc @param name does not match function parameter name. Expected '${funcParams[i]}' but got '${jsDocParams[i]}'`
+          });
+        }
+      }
+    }
+
+    return {
+      FunctionDeclaration: checkParameters,
+      MethodDefinition: checkParameters,
+    };
+  },
+};

package/rules/methods-naming.js

@@ -0,0 +1,55 @@
+// File: eslint-plugin-custom/private-public-methods.js
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Check if a method with JSDoc is properly private, protected or public",
+      category: "Possible Errors",
+      recommended: true
+    },
+    schema: [] // This rule does not take any options.
+  },
+
+  create: function(context) {
+    return {
+      MethodDefinition: function(node) {
+        const commentsBefore = context.getCommentsBefore(node);
+
+        const jsDocComment = commentsBefore.find(comment => 
+          comment.type === "Block" && comment.value.startsWith("*")
+        );
+
+        if (jsDocComment) {
+          const isPrivate = node.key.name.startsWith("__");
+          const isProtected = node.key.name.startsWith("_") && !node.key.name.startsWith("__");
+          const isPublic = jsDocComment.value.includes("@public");
+          const isProtectedJsDoc = jsDocComment.value.includes("@protected");
+          const isPrivateJsDoc = jsDocComment.value.includes("@private");
+
+          if (isPrivate && isPublic) {
+            context.report({
+              node: node,
+              message: "Methods starting with '__' should not be marked with '@public'."
+            });
+          } else if (isProtected && isPublic) {
+            context.report({
+              node: node,
+              message: "Methods starting with '_' should not be marked with '@public'."
+            });
+          } else if (!isPrivate && isPrivateJsDoc) {
+            context.report({
+              node: node,
+              message: "Methods not starting with '__' should not be marked with '@private'."
+            });
+          } else if (!isProtected && isProtectedJsDoc) {
+            context.report({
+              node: node,
+              message: "Methods not starting with '_' should not be marked with '@protected'."
+            });
+          }
+        }
+      }
+    };
+  }
+};

package/rules/multiline-comment-end-backslash.js

@@ -0,0 +1,33 @@
+// file: eslint-plugin-crisp/lib/rules/multiline-comment-end-backslash.js
+module.exports = {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "enforce that multiline comments should end with a backslash, except for JSDoc comments",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+    fixable: null, // Not auto-fixable
+  },
+  create(context) {
+    return {
+      Program() {
+        const sourceCode = context.getSourceCode();
+        const comments = sourceCode.getAllComments();
+
+        comments.forEach(comment => {
+          if (
+            comment.type === "Block" &&
+            !comment.value.trim().endsWith('\\') &&
+            !comment.value.trim().startsWith("*")
+          ) {
+            context.report({
+              node: comment,
+              message: "Multiline comments should end with a backslash '\\', unless they are JSDoc comments.",
+            });
+          }
+        });
+      },
+    };
+  },
+};

package/rules/new-line-after-block.js

@@ -0,0 +1,43 @@
+module.exports = {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "enforce a newline after control flow statements",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+  },
+  create(context) {
+    return {
+      IfStatement: checkForNewlineAfter,
+      ForStatement: checkForNewlineAfter,
+      WhileStatement: checkForNewlineAfter,
+      SwitchStatement: checkForNewlineAfter,
+      BreakStatement: checkForNewlineAfter,
+      ContinueStatement: checkForNewlineAfter,
+    };
+
+    function checkForNewlineAfter(node) {
+      const sourceCode = context.getSourceCode();
+      const tokenAfter = sourceCode.getTokenAfter(node, {includeComments: true});
+
+      if (!tokenAfter || tokenAfter.value === "}") {
+        return;
+      }
+
+      const lineDifference = tokenAfter.loc.start.line - node.loc.end.line;
+
+      if (lineDifference < 2) {
+        context.report({
+          node,
+          message: "Expected a newline after control flow statement.",
+        });
+      } else if (lineDifference > 2) {
+        context.report({
+          node,
+          message: "Expected exactly one newline after control flow statement, but found more.",
+        });
+      }
+    }
+  },
+};

package/rules/no-async.js

@@ -0,0 +1,38 @@
+module.exports = {
+  create: function(context) {
+    return {
+      FunctionDeclaration: function(node) {
+        if (node.async) {
+          context.report({
+            node: node,
+            message: "async/await is not allowed, use Promises instead.",
+          });
+        }
+      },
+      ArrowFunctionExpression: function(node) {
+        if (node.async) {
+          context.report({
+            node: node,
+            message: "async/await is not allowed, use Promises instead.",
+          });
+        }
+      },
+      FunctionExpression: function(node) {
+        if (node.async) {
+          context.report({
+            node: node,
+            message: "async/await is not allowed, use Promises instead.",
+          });
+        }
+      },
+      MethodDefinition: function(node) {
+        if (node.value && node.value.async) {
+          context.report({
+            node: node,
+            message: "async/await is not allowed, use Promises instead.",
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-trailing-spaces.js

@@ -0,0 +1,32 @@
+// file: eslint-plugin-crisp/lib/rules/no-trailing-spaces.js
+module.exports = {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "disallow trailing whitespace at the end of lines",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+  },
+  create(context) {
+    const sourceCode = context.getSourceCode();
+
+    return {
+      Program() {
+        const lines = sourceCode.lines;
+
+        lines.forEach((line, index) => {
+          if (/\s+$/u.test(line)) {
+            context.report({
+              loc: {
+                start: { line: index + 1, column: line.length },
+                end: { line: index + 1, column: line.length }
+              },
+              message: "Trailing spaces not allowed."
+            });
+          }
+        });
+      }
+    };
+  }
+};

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

@@ -0,0 +1,69 @@
+module.exports = {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "enforce only one space after = and : assignment",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+    fixable: "whitespace", // or "code" or "whitespace"
+    schema: [], // no options
+  },
+  create(context) {
+    return {
+      AssignmentExpression(node) {
+        const sourceCode = context.getSourceCode();
+        const operator = sourceCode.getTokenBefore(node.right);
+
+        if (sourceCode.getTokenAfter(operator).loc.start.column - operator.loc.end.column > 1) {
+          context.report({
+            node: operator,
+            message: "There should be exactly one space after '=' operator",
+            fix(fixer) {
+              return fixer.replaceTextRange(
+                [operator.range[1], sourceCode.getTokenAfter(operator).range[0]],
+                " "
+              );
+            }
+          });
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.init) {
+          const sourceCode = context.getSourceCode();
+          const operator = sourceCode.getTokenBefore(node.init);
+
+          if (sourceCode.getTokenAfter(operator).loc.start.column - operator.loc.end.column > 1) {
+            context.report({
+              node: operator,
+              message: "There should be exactly one space after '=' operator",
+              fix(fixer) {
+                return fixer.replaceTextRange(
+                  [operator.range[1], sourceCode.getTokenAfter(operator).range[0]],
+                  " "
+                );
+              }
+            });
+          }
+        }
+      },
+      Property(node) {
+        const sourceCode = context.getSourceCode();
+        const operator = sourceCode.getTokenBefore(node.value);
+
+        if (sourceCode.getTokenAfter(operator).loc.start.column - operator.loc.end.column > 1) {
+          context.report({
+            node: operator,
+            message: "There should be exactly one space after ':'' operator",
+            fix(fixer) {
+              return fixer.replaceTextRange(
+                [operator.range[1], sourceCode.getTokenAfter(operator).range[0]],
+                " "
+              );
+            }
+          });
+        }
+      },
+    };
+  },
+};

package/rules/regex-in-constructor.js

@@ -0,0 +1,28 @@
+// file: eslint-plugin-crisp/lib/rules/regex-in-constructor.js
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce regex definitions in the constructor",
+      category: "Best Practices",
+      recommended: false,
+    },
+    fixable: null,  // This rule is not auto-fixable
+  },
+  create(context) {
+    return {
+      'MethodDefinition[kind!="constructor"] > FunctionExpression > BlockStatement': function(node) {
+        const regexes = context.getSourceCode().getTokens(node).filter(token => token.type === "RegularExpression");
+
+        if (regexes.length > 0) {
+          context.report({
+            node,
+            message: "Regular expressions should be defined in the constructor."
+          });
+        }
+      }
+    };
+  },
+};
+
+

package/rules/ternary-parenthesis.js

@@ -0,0 +1,29 @@
+module.exports = {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "enforce parentheses around the condition in ternary expressions, if there is an operator in the condition",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+    schema: [], // no options
+  },
+  create(context) {
+    return {
+      ConditionalExpression(node) {
+        if (node.test.type === "BinaryExpression" || node.test.type === "LogicalExpression") {
+          const sourceCode = context.getSourceCode();
+          const beforeOperatorToken = sourceCode.getTokenBefore(node.test);
+          const afterOperatorToken = sourceCode.getTokenAfter(node.test);
+
+          if (beforeOperatorToken.value !== "(" || afterOperatorToken.value !== ")") {
+            context.report({
+              node,
+              message: "The condition in ternary expressions with an operator should be wrapped in parentheses",
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/two-lines-between-class-members.js

@@ -0,0 +1,45 @@
+// file: eslint-plugin-crisp/lib/rules/two-lines-between-class-members.js
+module.exports = {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "enforce two line breaks between class members",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+  },
+  create(context) {
+    return {
+      MethodDefinition(node) {
+        const sourceCode = context.getSourceCode();
+        const lines = sourceCode.lines;
+
+        const parent = node.parent;
+
+        // Ensure we are in a class and not the first method
+        if (parent && parent.type === "ClassBody" && parent.body[0] !== node) {
+          const methodIndex = parent.body.indexOf(node);
+          const previousMethod = parent.body[methodIndex - 1];
+          const lineOfCurrentMethod = node.loc.start.line;
+          const lineOfPreviousMethodEnd = previousMethod.loc.end.line;
+
+          // Count the empty lines between the end of the previous method and the start of the current one
+          let emptyLineCount = 0;
+          for (let i = lineOfPreviousMethodEnd; i < lineOfCurrentMethod; i++) {
+            if (lines[i].trim() === "" && !lines[i].includes("*")) {
+              emptyLineCount++;
+            }
+          }
+
+          // Report an error if there are not exactly two empty lines
+          if (emptyLineCount !== 2) {
+            context.report({
+              node,
+              message: "Expected exactly two line breaks between class methods.",
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/variable-names.js

@@ -0,0 +1,43 @@
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce that variables defined within a method start with '_', except for parameters",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+    schema: [], // no options
+  },
+  create(context) {
+    function checkDeclaration(node, body) {
+      body.body.forEach((statement) => {
+        if (statement.type === "VariableDeclaration") {
+          statement.declarations.forEach((declaration) => {
+            if (declaration.id.name && !declaration.id.name.startsWith("_")) {
+              context.report({
+                node: declaration,
+                message: "Variables defined within a method should start with '_'",
+              });
+            }
+          });
+        }
+      });
+    }
+
+    return {
+      MethodDefinition(node) {
+        checkDeclaration(node, node.value.body);
+      },
+      ArrowFunctionExpression(node) {
+        if (node.body.type === "BlockStatement") {
+          checkDeclaration(node, node.body);
+        }
+      },
+      FunctionExpression(node) {
+        if (node.body.type === "BlockStatement") {
+          checkDeclaration(node, node.body);
+        }
+      },
+    };
+  },
+};