eslint-plugin-effector 0.3.1 → 0.5.0

package/README.md

@@ -25,7 +25,7 @@ Add `effector` to the plugins section of your `.eslintrc` configuration file. Yo
 ```json
 {
   "plugins": ["effector"],
-  "extends": ["plugin:effector/recommended"]
+  "extends": ["plugin:effector/recommended", "plugin:effector/scope"]
 }
 ```
 
@@ -39,12 +39,43 @@ To configure individual rules:
 }
 ```
 
-## Supported Rules
+### Available presets
 
-- [effector/enforce-store-naming-convention](/rules/enforce-store-naming-convention/enforce-store-naming-convention.md)
-- [effector/enforce-effect-naming-convention](/rules/enforce-effect-naming-convention/enforce-effect-naming-convention.md)
-- [effector/no-getState](/rules/no-getState/no-getState.md)
-- [effector/no-unnecessary-duplication](/rules/no-unnecessary-duplication/no-unnecessary-duplication.md)
-- [effector/no-useless-methods](/rules/no-useless-methods/no-useless-methods.md)
-- [effector/no-ambiguity-target](/rules/no-ambiguity-target/no-ambiguity-target.md)
-- [effector/prefer-sample-over-forward-with-mapping](/rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.md)
+#### plugin:effector/recommended
+
+This preset is recommended for most projects.
+
+#### plugin:effector/scope
+
+This preset is recommended for projects that use [Fork API](https://effector.dev/docs/api/effector/scope). You can read more about Fork API in [an article](https://dev.to/effector/the-best-part-of-effector-4c27).
+
+#### plugin:effector/react
+
+This preset is recommended for projects that use [React](https://reactjs.org) with Effector.
+
+### Supported rules
+
+- [effector/enforce-store-naming-convention](rules/enforce-store-naming-convention/enforce-store-naming-convention.md)
+- [effector/enforce-effect-naming-convention](rules/enforce-effect-naming-convention/enforce-effect-naming-convention.md)
+- [effector/no-getState](rules/no-getState/no-getState.md)
+- [effector/no-unnecessary-duplication](rules/no-unnecessary-duplication/no-unnecessary-duplication.md)
+- [effector/no-useless-methods](rules/no-useless-methods/no-useless-methods.md)
+- [effector/no-ambiguity-target](rules/no-ambiguity-target/no-ambiguity-target.md)
+- [effector/prefer-sample-over-forward-with-mapping](rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.md)
+- [effector/no-watch](rules/no-watch/no-watch.md)
+- [effector/no-unnecessary-combination](rules/no-unnecessary-combination/no-unnecessary-combination.md)
+- [effector/no-duplicate-on](rules/no-duplicate-on/no-duplicate-on.md)
+- [effector/strict-effect-handlers](rules/strict-effect-handlers/strict-effect-handlers.md)
+- [effector/enforce-gate-naming-convention](rules/enforce-gate-naming-convention/enforce-gate-naming-convention.md)
+
+## Maintenance
+
+### Release flow
+
+1. Bump `version` in [package.json](package.json)
+2. Fill [CHANGELOG.md](CHANGELOG.md)
+3. Commit changes by `git commit -m "Release X.X.X"`
+4. Create git tag for release by `git tag -a vX.X.X -m "vX.X.X"`
+5. Push changes to remote by `git push --follow-tags`
+6. Release package to registry by `yarn clean-publish`
+7. Fill release page with changelog on GitHub

package/config/react.js

@@ -0,0 +1,5 @@
+module.exports = {
+  rules: {
+    "effector/enforce-gate-naming-convention": "error",
+  },
+};

package/config/recommended.js

@@ -7,5 +7,8 @@ module.exports = {
     "effector/no-unnecessary-duplication": "warn",
     "effector/prefer-sample-over-forward-with-mapping": "warn",
     "effector/no-ambiguity-target": "warn",
+    "effector/no-watch": "warn",
+    "effector/no-unnecessary-combination": "warn",
+    "effector/no-duplicate-on": "error",
   },
 };

package/config/scope.js

@@ -0,0 +1,5 @@
+module.exports = {
+  rules: {
+    "effector/strict-effect-handlers": "error",
+  },
+};

package/index.js

@@ -7,8 +7,15 @@ module.exports = {
     "prefer-sample-over-forward-with-mapping": require("./rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping"),
     "no-useless-methods": require("./rules/no-useless-methods/no-useless-methods"),
     "no-ambiguity-target": require("./rules/no-ambiguity-target/no-ambiguity-target"),
+    "no-watch": require("./rules/no-watch/no-watch"),
+    "no-unnecessary-combination": require("./rules/no-unnecessary-combination/no-unnecessary-combination"),
+    "no-duplicate-on": require("./rules/no-duplicate-on/no-duplicate-on"),
+    "strict-effect-handlers": require("./rules/strict-effect-handlers/strict-effect-handlers"),
+    "enforce-gate-naming-convention": require("./rules/enforce-gate-naming-convention/enforce-gate-naming-convention"),
   },
   configs: {
     recommended: require("./config/recommended"),
-  }
+    scope: require("./config/scope"),
+    react: require("./config/react"),
+  },
 };

package/package.json

@@ -1,33 +1,31 @@
 {
   "name": "eslint-plugin-effector",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Enforcing best practices for Effector",
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "eslintplugin",
+    "effector"
+  ],
+  "repository": "effector/eslint-plugin",
   "main": "index.js",
   "author": "Igor Kamyshev <igor@kamyshev.me>",
   "license": "MIT",
-  "scripts": {
-    "test": "jest"
-  },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
     "node": "^14 || ^16"
   },
-  "devDependencies": {
-    "@typescript-eslint/experimental-utils": "^4.29.3",
-    "@typescript-eslint/parser": "^4.29.3",
-    "effector": "^22.0.0",
-    "eslint": "^7.32.0",
-    "glob": "^7.1.7",
-    "jest": "^27.1.0",
-    "typescript": "^4.4.2"
-  },
   "peerDependencies": {
     "effector": "*",
-    "eslint": "*"
+    "eslint": "7 || 8"
   },
   "dependencies": {
     "prettier": "^2.3.2"
+  },
+  "nano-staged": {
+    "*.{js,ts,md}": "prettier --write"
   }
-}
+}

package/rules/enforce-effect-naming-convention/enforce-effect-naming-convention.js

@@ -1,6 +1,7 @@
-const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { nodeTypeIs } = require("../../utils/node-type-is");
+const { namingOf } = require("../../utils/naming");
 
 module.exports = {
   meta: {
@@ -10,6 +11,7 @@ module.exports = {
         "Enforce Fx as a suffix for any effect created by Effector methods",
       category: "Naming",
       recommended: true,
+      url: createLinkToRule("enforce-effect-naming-convention"),
     },
     messages: {
       invalidName:
@@ -17,6 +19,7 @@ module.exports = {
       renameEffect: 'Rename "{{ effectName }}" to "{{ effectName }}Fx"',
     },
     schema: [],
+    hasSuggestions: true,
   },
   create(context) {
     const parserServices = context.parserServices;
@@ -24,13 +27,10 @@ module.exports = {
     if (parserServices.hasFullTypeInformation) {
       return {
         VariableDeclarator(node) {
-          const checker = parserServices.program.getTypeChecker();
-          const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-          const type = checker.getTypeAtLocation(originalNode.initializer);
-
-          const isEffectorEffect =
-            type?.symbol?.escapedName === "Effect" &&
-            type?.symbol?.parent?.escapedName?.includes("effector");
+          const isEffectorEffect = nodeTypeIs.effect({
+            node,
+            context,
+          });
 
           if (!isEffectorEffect) {
             return;
@@ -38,11 +38,9 @@ module.exports = {
 
           const effectName = node.id.name;
 
-          if (effectName?.endsWith("Fx")) {
-            return;
+          if (namingOf.effect.isInvalid({ name: effectName })) {
+            reportEffectNameConventionViolation({ context, node, effectName });
           }
-
-          reportEffectNameConventionViolation({ context, node, effectName });
         },
       };
     }
@@ -51,7 +49,11 @@ module.exports = {
     const importedFromEffector = new Map();
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
       },
       CallExpression(node) {
         // Effect creation with method
@@ -74,7 +76,7 @@ module.exports = {
           }
 
           const effectName = node.parent.id.name;
-          if (effectName.endsWith("Fx")) {
+          if (namingOf.effect.isValid({ name: effectName })) {
             continue;
           }
 
@@ -98,7 +100,7 @@ module.exports = {
           }
 
           const effectName = node.parent.id.name;
-          if (effectName.endsWith("Fx")) {
+          if (namingOf.effect.isValid({ name: effectName })) {
             return;
           }
 

package/rules/enforce-gate-naming-convention/enforce-gate-naming-convention.js

@@ -0,0 +1,114 @@
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { nodeTypeIs } = require("../../utils/node-type-is");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { namingOf } = require("../../utils/naming");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce first capital letter for gate naming",
+      category: "Naming",
+      recommended: true,
+      url: createLinkToRule("enforce-gate-naming-convention"),
+    },
+    messages: {
+      invalidName:
+        'Gate "{{ gateName }}" should be named with first capital letter, rename it to "{{ correctedGateName }}"',
+      renameGate: 'Rename "{{ gateName }}" to "{{ correctedGateName }}"',
+    },
+    schema: [],
+    hasSuggestions: true,
+  },
+  create(context) {
+    const parserServices = context.parserServices;
+    // TypeScript-way
+    if (parserServices.hasFullTypeInformation) {
+      return {
+        VariableDeclarator(node) {
+          const isEffectorGate = nodeTypeIs.gate({
+            node,
+            context,
+          });
+
+          if (!isEffectorGate) {
+            return;
+          }
+
+          const gateName = node.id.name;
+
+          if (namingOf.gate.isInvalid({ name: gateName })) {
+            reportGateNameConventionViolation({ context, node, gateName });
+          }
+        },
+      };
+    }
+
+    // JavaScript-way
+    const importedFromEffectorReact = new Map();
+    return {
+      ImportDeclaration(node) {
+        extractImportedFrom({
+          importMap: importedFromEffectorReact,
+          node,
+          packageName: "effector-react",
+        });
+      },
+      CallExpression(node) {
+        // Effect creation with method
+        const GATE_CREATION_METHODS = ["createGate"];
+        for (const method of GATE_CREATION_METHODS) {
+          const localMethod = importedFromEffectorReact.get(method);
+          if (!localMethod) {
+            continue;
+          }
+
+          const isEffectorGateCreation = node.callee.name === localMethod;
+          if (!isEffectorGateCreation) {
+            continue;
+          }
+
+          const resultSavedInVariable =
+            node.parent.type === "VariableDeclarator";
+          if (!resultSavedInVariable) {
+            continue;
+          }
+
+          const gateName = node.parent.id.name;
+          if (namingOf.gate.isValid({ name: gateName })) {
+            continue;
+          }
+
+          reportGateNameConventionViolation({
+            context,
+            node: node.parent,
+            gateName,
+          });
+        }
+      },
+    };
+  },
+};
+
+function reportGateNameConventionViolation({ context, node, gateName }) {
+  const [firstChar, ...restChars] = gateName.split("");
+  const correctedGateName = [firstChar.toUpperCase(), ...restChars].join("");
+
+  context.report({
+    node,
+    messageId: "invalidName",
+    data: {
+      gateName,
+      correctedGateName,
+    },
+    suggest: [
+      {
+        messageId: "renameGate",
+        data: { gateName, correctedGateName },
+        fix(fixer) {
+          return fixer.replaceTextRange(node.id.range, correctedGateName);
+        },
+      },
+    ],
+  });
+}

package/rules/enforce-gate-naming-convention/enforce-gate-naming-convention.md

@@ -0,0 +1,11 @@
+# effector/enforce-gate-naming-convention
+
+Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable with gate. Every gate is a react-component, so it should be named as regular react-compoent.
+
+```ts
+// 👍 nice name
+const MyFavoritePageGate = createGate();
+
+// 👎 bad name
+const otherFavoritePageGate = createGate();
+```

package/rules/enforce-store-naming-convention/enforce-store-naming-convention.js

@@ -1,26 +1,34 @@
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { namingOf } = require("../../utils/naming");
 const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
-const { isStoreNameValid } = require("../../utils/is-store-name-valid");
-const { validateStoreNameConvention } = require("../../utils/validate-store-name-convention");
-const { getStoreNameConvention } = require("../../utils/get-store-name-convention");
-const { getCorrectedStoreName } = require("../../utils/get-corrected-store-name");
+  validateStoreNameConvention,
+} = require("../../utils/validate-store-name-convention");
+const {
+  getStoreNameConvention,
+} = require("../../utils/get-store-name-convention");
+const {
+  getCorrectedStoreName,
+} = require("../../utils/get-corrected-store-name");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { nodeTypeIs } = require("../../utils/node-type-is");
 
 module.exports = {
   meta: {
     type: "problem",
     docs: {
       description:
-          "Enforce $ as a prefix or postfix for any store created by Effector methods",
+        "Enforce $ as a prefix or postfix for any store created by Effector methods",
       category: "Naming",
       recommended: true,
+      url: createLinkToRule("enforce-store-naming-convention"),
     },
     messages: {
       invalidName:
-          'Store "{{ storeName }}" should be named with {{ storeNameConvention }}, rename it to "{{ correctedStoreName }}"',
+        'Store "{{ storeName }}" should be named with {{ storeNameConvention }}, rename it to "{{ correctedStoreName }}"',
       renameStore: 'Rename "{{ storeName }}" to "{{ correctedStoreName }}"',
     },
     schema: [],
+    hasSuggestions: true,
   },
   create(context) {
     const { parserServices } = context;
@@ -31,13 +39,10 @@ module.exports = {
     if (parserServices.hasFullTypeInformation) {
       return {
         VariableDeclarator(node) {
-          const checker = parserServices.program.getTypeChecker();
-          const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-          const type = checker.getTypeAtLocation(originalNode.initializer);
-
-          const isEffectorStore =
-              type?.symbol?.escapedName === "Store" &&
-              type?.symbol?.parent?.escapedName?.includes("effector");
+          const isEffectorStore = nodeTypeIs.store({
+            node,
+            context,
+          });
 
           if (!isEffectorStore) {
             return;
@@ -45,15 +50,13 @@ module.exports = {
 
           const storeName = node.id.name;
 
-          if (isStoreNameValid(storeName, context)) {
-            return;
+          if (namingOf.store.isInvalid({ name: storeName, context })) {
+            reportStoreNameConventionViolation({
+              context,
+              node,
+              storeName,
+            });
           }
-
-          reportStoreNameConventionViolation({
-            context,
-            node,
-            storeName
-          });
         },
       };
     }
@@ -62,7 +65,11 @@ module.exports = {
     const importedFromEffector = new Map();
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
       },
       CallExpression(node) {
         // Store creation with method
@@ -79,21 +86,21 @@ module.exports = {
           }
 
           const resultSavedInVariable =
-              node.parent.type === "VariableDeclarator";
+            node.parent.type === "VariableDeclarator";
           if (!resultSavedInVariable) {
             continue;
           }
 
           const storeName = node.parent.id.name;
 
-          if (isStoreNameValid(storeName, context)) {
+          if (namingOf.store.isValid({ name: storeName, context })) {
             continue;
           }
 
           reportStoreNameConventionViolation({
             context,
             node: node.parent,
-            storeName
+            storeName,
           });
           return;
         }
@@ -102,27 +109,28 @@ module.exports = {
         if (node.callee?.property?.name === "map") {
           const storeNameCreatedFromMap = node.callee?.object?.name;
 
-          if (!isStoreNameValid(storeNameCreatedFromMap, context)) {
+          if (
+            namingOf.store.isInvalid({ name: storeNameCreatedFromMap, context })
+          ) {
             return;
           }
 
           const resultSavedInVariable =
-              node.parent.type === "VariableDeclarator";
+            node.parent.type === "VariableDeclarator";
           if (!resultSavedInVariable) {
             return;
           }
 
           const storeName = node.parent.id.name;
 
-          if (isStoreNameValid(storeName, context)) {
+          if (namingOf.store.isValid({ name: storeName, context })) {
             return;
           }
 
-
           reportStoreNameConventionViolation({
             context,
             node: node.parent,
-            storeName
+            storeName,
           });
           return;
         }
@@ -130,24 +138,24 @@ module.exports = {
         // Store creation in domain
         const STORE_IN_DOMAIN_CREATION_METHODS = ["createStore", "store"];
         if (
-            STORE_IN_DOMAIN_CREATION_METHODS.includes(node.callee?.property?.name)
+          STORE_IN_DOMAIN_CREATION_METHODS.includes(node.callee?.property?.name)
         ) {
           const resultSavedInVariable =
-              node.parent.type === "VariableDeclarator";
+            node.parent.type === "VariableDeclarator";
           if (!resultSavedInVariable) {
             return;
           }
 
           const storeName = node.parent.id.name;
 
-          if (isStoreNameValid(storeName, context)) {
+          if (namingOf.store.isValid({ name: storeName, context })) {
             return;
           }
 
           reportStoreNameConventionViolation({
             context,
             node: node.parent,
-            storeName
+            storeName,
           });
           return;
         }
@@ -157,7 +165,6 @@ module.exports = {
 };
 
 function reportStoreNameConventionViolation({ context, node, storeName }) {
-
   const storeNameConvention = getStoreNameConvention(context);
   const correctedStoreName = getCorrectedStoreName(storeName, context);
 
@@ -167,12 +174,12 @@ function reportStoreNameConventionViolation({ context, node, storeName }) {
     data: {
       storeName,
       correctedStoreName,
-      storeNameConvention
+      storeNameConvention,
     },
     suggest: [
       {
         messageId: "renameStore",
-        data: { storeName },
+        data: { storeName, correctedStoreName },
         fix(fixer) {
           return fixer.replaceTextRange(node.id.range, correctedStoreName);
         },
@@ -180,4 +187,3 @@ function reportStoreNameConventionViolation({ context, node, storeName }) {
     ],
   });
 }
-

package/rules/enforce-store-naming-convention/enforce-store-naming-convention.md

@@ -3,7 +3,9 @@
 Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable with store. Depending on the configuration your stores should be distinguished by a prefix or a postfix $. Enforces prefix convention by default.
 
 ## Prefix convention
+
 When configured as:
+
 ```js
 module.exports = {
   rules: {
@@ -11,17 +13,21 @@ module.exports = {
   },
 };
 ```
+
 Prefix convention will be enforced:
+
 ```ts
 // 👍 nice name
 const $name = createStore(null);
 
 // 👎 bad name
-const name = createStrore(null);
+const name = createStore(null);
 ```
+
 ## Postfix convention
 
 When configured as:
+
 ```js
 module.exports = {
   rules: {
@@ -29,12 +35,14 @@ module.exports = {
   },
   settings: {
     effector: {
-      storeNameConvention: "postfix"
-    }
-  }
+      storeNameConvention: "postfix",
+    },
+  },
 };
 ```
+
 Postfix convention will be enforced:
+
 ```ts
 // 👍 nice name
 const name$ = createStore(null);

package/rules/no-ambiguity-target/no-ambiguity-target.js

@@ -1,7 +1,6 @@
-const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { traverseParentByType } = require("../../utils/traverse-parent-by-type");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
 
 module.exports = {
   meta: {
@@ -10,6 +9,7 @@ module.exports = {
       description: "Forbids ambiguity targets in `sample` and `guard`",
       category: "Quality",
       recommended: true,
+      url: createLinkToRule("no-ambiguity-target"),
     },
     messages: {
       ambiguityTarget:
@@ -22,7 +22,11 @@ module.exports = {
 
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
       },
       CallExpression(node) {
         const POSSIBLE_USELESS_METHODS = ["sample", "guard"];