eslint-plugin-crisp 1.0.0 → 1.0.2

package/package.json

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

package/recommended.js

@@ -13,6 +13,7 @@ module.exports = {
     "semi": ["error", "always"],
     "max-len": ["error", 80],
     "comma-dangle": ["error", "never"],
+    "arrow-parens": ["error", "always"],
     "crisp/align-one-var": ["error"],
     "crisp/multiline-comment-end-backslash": "error",
     "crisp/const": "error",
@@ -25,11 +26,14 @@ module.exports = {
     "crisp/one-space-after-operator": "error",
     "crisp/no-trailing-spaces": "error",
     "crisp/ternary-parenthesis": "error",
-    "crisp/variable-names": "error",
+    "crisp/variable-names": ["error", {
+      "variableExceptions": ["fn"]
+    }],
     "crisp/jsdoc-match-params": ["error", { "exceptions": ["constructor"] }],
 
     "crisp/constructor-variables": ["error", {
-      "exceptions": ["client"]
+      "filenameExceptions": ["app.js"],
+      "variableExceptions": ["client"]
     }],
     "jsdoc/require-jsdoc": ["error", {
       "require": {

package/rules/constructor-variables.js

@@ -9,7 +9,11 @@ module.exports = {
       {
         type: "object",
         properties: {
-          exceptions: {
+          filenameExceptions: {
+            type: "array",
+            items: { type: "string" },
+          },
+          variableExceptions: {
             type: "array",
             items: { type: "string" },
           },
@@ -21,13 +25,17 @@ module.exports = {
 
   create(context) {
     const options = context.options[0] || {};
-    const exceptions = options.exceptions || [];
+    const filename = context.getFilename();
+    const filenameExceptions = options.filenameExceptions || [];
+    const variableExceptions = options.variableExceptions || [];
+
+    const isFilenameException = filenameExceptions.some((exception) => filename.endsWith(exception));
 
     return {
       "MethodDefinition[kind='constructor'] > FunctionExpression > BlockStatement > ExpressionStatement > AssignmentExpression": function(node) {
-        if(node.left.type === "MemberExpression" && node.left.object.type === "ThisExpression"){
+        if(node.left.type === "MemberExpression" && node.left.object.type === "ThisExpression") {
           const varName = node.left.property.name;
-          if (!varName.startsWith("_") && !exceptions.includes(varName)) {
+          if (!varName.startsWith("_") && !isFilenameException && !variableExceptions.includes(varName)) {
             context.report({
               node,
               message: "Class properties in the constructor should start with '_', except for specified exceptions",

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

@@ -18,6 +18,7 @@ module.exports = {
         comments.forEach(comment => {
           if (
             comment.type === "Block" &&
+            comment.loc.start.line !== comment.loc.end.line &&
             !comment.value.trim().endsWith('\\') &&
             !comment.value.trim().startsWith("*")
           ) {

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

@@ -25,6 +25,10 @@ module.exports = {
         return;
       }
 
+      if (tokenAfter.type === "Line" && tokenAfter.value.trim().startsWith("jscs")) {
+        return;
+      }
+
       const lineDifference = tokenAfter.loc.start.line - node.loc.end.line;
 
       if (lineDifference < 2) {

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

@@ -2,7 +2,7 @@ module.exports = {
   meta: {
     type: "layout",
     docs: {
-      description: "enforce only one space after = and : assignment",
+      description: "enforce at least one space before and exactly one space after = and : assignment",
       category: "Stylistic Issues",
       recommended: false,
     },
@@ -10,59 +10,37 @@ module.exports = {
     schema: [], // no options
   },
   create(context) {
+    const sourceCode = context.getSourceCode();
+
+    const checkSpacing = (node, operatorToken, operatorName) => {
+      if (Math.abs(sourceCode.getTokenBefore(operatorToken).loc.end.column - operatorToken.loc.start.column) < 1 || sourceCode.getTokenAfter(operatorToken).loc.start.column - operatorToken.loc.end.column > 1) {
+        context.report({
+          node: operatorToken,
+          message: `There should be at least one space before and exactly one space after '${operatorName}'`,
+          fix(fixer) {
+            return fixer.replaceTextRange(
+              [sourceCode.getTokenBefore(operatorToken).range[1], sourceCode.getTokenAfter(operatorToken).range[0]],
+              ` ${operatorName} `
+            );
+          }
+        });
+      }
+    }
+
     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]],
-                " "
-              );
-            }
-          });
-        }
+        const operatorToken = sourceCode.getTokenBefore(node.right);
+        checkSpacing(node, operatorToken, '=');
       },
       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]],
-                  " "
-                );
-              }
-            });
-          }
+          const operatorToken = sourceCode.getTokenBefore(node.init);
+          checkSpacing(node, operatorToken, '=');
         }
       },
       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]],
-                " "
-              );
-            }
-          });
-        }
+        const operatorToken = sourceCode.getTokenBefore(node.value);
+        checkSpacing(node, operatorToken, ':');
       },
     };
   },

package/rules/variable-names.js

@@ -6,17 +6,30 @@ module.exports = {
       category: "Stylistic Issues",
       recommended: false,
     },
-    schema: [], // no options
+    schema: [{
+      type: "object",
+      properties: {
+        variableExceptions: {
+          type: "array",
+          items: { type: "string" },
+          uniqueItems: true,
+        }
+      },
+      additionalProperties: false,
+    }], // options schema updated
   },
   create(context) {
+    const options = context.options[0] || {};
+    const variableExceptions = options.variableExceptions || [];
+
     function checkDeclaration(node, body) {
       body.body.forEach((statement) => {
         if (statement.type === "VariableDeclaration") {
           statement.declarations.forEach((declaration) => {
-            if (declaration.id.name && !declaration.id.name.startsWith("_")) {
+            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 '_'",
+                message: `Variables defined within a method should start with '_' ({${declaration.id.name}})`,
               });
             }
           });