eslint-plugin-effector 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v0.3.0
+
+- Add new rule: `no-useless-methods` ([PR #41](https://github.com/effector/eslint-plugin/pull/41))
+- Add new rule: `no-ambiguity-target` ([PR #42](https://github.com/effector/eslint-plugin/pull/42))
+- Add possibility to configure store's naming convention — suffix of prefix ([PR #37](https://github.com/effector/eslint-plugin/pull/37) by @ilyaryabchinski)
+
 ## v0.2.0
 
 - Add tests against Effector 22

package/README.md

@@ -45,4 +45,6 @@ To configure individual rules:
 - [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)

package/config/recommended.js

@@ -3,7 +3,9 @@ module.exports = {
     "effector/enforce-store-naming-convention": "error",
     "effector/enforce-effect-naming-convention": "error",
     "effector/no-getState": "error",
+    "effector/no-useless-methods": "error",
     "effector/no-unnecessary-duplication": "warn",
     "effector/prefer-sample-over-forward-with-mapping": "warn",
+    "effector/no-ambiguity-target": "warn",
   },
 };

package/index.js

@@ -5,8 +5,10 @@ module.exports = {
     "no-getState": require("./rules/no-getState/no-getState"),
     "no-unnecessary-duplication": require("./rules/no-unnecessary-duplication/no-unnecessary-duplication"),
     "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"),
   },
   configs: {
     recommended: require("./config/recommended"),
-  },
+  }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-effector",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Enforcing best practices for Effector",
   "main": "index.js",
   "author": "Igor Kamyshev <igor@kamyshev.me>",

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

@@ -1,25 +1,32 @@
 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");
 
 module.exports = {
   meta: {
     type: "problem",
     docs: {
       description:
-        "Enforce $ as a prefix for any store created by Effector methods",
+          "Enforce $ as a prefix or postfix for any store created by Effector methods",
       category: "Naming",
       recommended: true,
     },
     messages: {
       invalidName:
-        'Store "{{ storeName }}" should be named with prefix, rename it to "${{ storeName }}"',
-      renameStore: 'Rename "{{ storeName }}" to "${{ storeName }}"',
+          'Store "{{ storeName }}" should be named with {{ storeNameConvention }}, rename it to "{{ correctedStoreName }}"',
+      renameStore: 'Rename "{{ storeName }}" to "{{ correctedStoreName }}"',
     },
     schema: [],
   },
   create(context) {
-    const parserServices = context.parserServices;
+    const { parserServices } = context;
+
+    validateStoreNameConvention(context);
+
     // TypeScript-way
     if (parserServices.hasFullTypeInformation) {
       return {
@@ -29,8 +36,8 @@ module.exports = {
           const type = checker.getTypeAtLocation(originalNode.initializer);
 
           const isEffectorStore =
-            type?.symbol?.escapedName === "Store" &&
-            type?.symbol?.parent?.escapedName?.includes("effector");
+              type?.symbol?.escapedName === "Store" &&
+              type?.symbol?.parent?.escapedName?.includes("effector");
 
           if (!isEffectorStore) {
             return;
@@ -38,11 +45,15 @@ module.exports = {
 
           const storeName = node.id.name;
 
-          if (storeName?.startsWith("$")) {
+          if (isStoreNameValid(storeName, context)) {
             return;
           }
 
-          reportStoreNameConventionViolation({ context, node, storeName });
+          reportStoreNameConventionViolation({
+            context,
+            node,
+            storeName
+          });
         },
       };
     }
@@ -68,47 +79,50 @@ module.exports = {
           }
 
           const resultSavedInVariable =
-            node.parent.type === "VariableDeclarator";
+              node.parent.type === "VariableDeclarator";
           if (!resultSavedInVariable) {
             continue;
           }
 
           const storeName = node.parent.id.name;
-          if (storeName.startsWith("$")) {
+
+          if (isStoreNameValid(storeName, context)) {
             continue;
           }
 
           reportStoreNameConventionViolation({
             context,
             node: node.parent,
-            storeName,
+            storeName
           });
           return;
         }
 
         // Store creation with .map
         if (node.callee?.property?.name === "map") {
-          const objectIsEffectorStore =
-            node.callee?.object?.name?.startsWith?.("$");
-          if (!objectIsEffectorStore) {
+          const storeNameCreatedFromMap = node.callee?.object?.name;
+
+          if (!isStoreNameValid(storeNameCreatedFromMap, context)) {
             return;
           }
 
           const resultSavedInVariable =
-            node.parent.type === "VariableDeclarator";
+              node.parent.type === "VariableDeclarator";
           if (!resultSavedInVariable) {
             return;
           }
 
           const storeName = node.parent.id.name;
-          if (storeName.startsWith("$")) {
+
+          if (isStoreNameValid(storeName, context)) {
             return;
           }
 
+
           reportStoreNameConventionViolation({
             context,
             node: node.parent,
-            storeName,
+            storeName
           });
           return;
         }
@@ -116,23 +130,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 (storeName.startsWith("$")) {
+
+          if (isStoreNameValid(storeName, context)) {
             return;
           }
 
           reportStoreNameConventionViolation({
             context,
             node: node.parent,
-            storeName,
+            storeName
           });
           return;
         }
@@ -142,20 +157,27 @@ module.exports = {
 };
 
 function reportStoreNameConventionViolation({ context, node, storeName }) {
+
+  const storeNameConvention = getStoreNameConvention(context);
+  const correctedStoreName = getCorrectedStoreName(storeName, context);
+
   context.report({
     node,
     messageId: "invalidName",
     data: {
       storeName,
+      correctedStoreName,
+      storeNameConvention
     },
     suggest: [
       {
         messageId: "renameStore",
         data: { storeName },
         fix(fixer) {
-          return fixer.insertTextBeforeRange(node.range, "$");
+          return fixer.replaceTextRange(node.id.range, correctedStoreName);
         },
       },
     ],
   });
 }
+

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

@@ -1,7 +1,17 @@
 # effector/enforce-store-naming-convention
 
-Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable with store. Your stores should be distingueshed by a prefix $. For example, `$name` is a store,`name` is not.
+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: {
+    "effector/enforce-store-naming-convention": "error",
+  },
+};
+```
+Prefix convention will be enforced:
 ```ts
 // 👍 nice name
 const $name = createStore(null);
@@ -9,3 +19,26 @@ const $name = createStore(null);
 // 👎 bad name
 const name = createStrore(null);
 ```
+## Postfix convention
+
+When configured as:
+```js
+module.exports = {
+  rules: {
+    "effector/enforce-store-naming-convention": "error",
+  },
+  settings: {
+    effector: {
+      storeNameConvention: "postfix"
+    }
+  }
+};
+```
+Postfix convention will be enforced:
+```ts
+// 👍 nice name
+const name$ = createStore(null);
+
+// 👎 bad name
+const name = createStrore(null);
+```

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

@@ -0,0 +1,71 @@
+const {
+  extractImportedFromEffector,
+} = require("../../utils/extract-imported-from-effector");
+const { traverseParentByType } = require("../../utils/traverse-parent-by-type");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbids ambiguity targets in `sample` and `guard`",
+      category: "Quality",
+      recommended: true,
+    },
+    messages: {
+      ambiguityTarget:
+        "Method `{{ methodName }}` returns `target` and assigns the result to a variable. Consider removing one of them.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const importedFromEffector = new Map();
+
+    return {
+      ImportDeclaration(node) {
+        extractImportedFromEffector(importedFromEffector, node);
+      },
+      CallExpression(node) {
+        const POSSIBLE_USELESS_METHODS = ["sample", "guard"];
+        for (const method of POSSIBLE_USELESS_METHODS) {
+          const localMethod = importedFromEffector.get(method);
+          if (!localMethod) {
+            continue;
+          }
+
+          const isEffectorMethod = node?.callee?.name === localMethod;
+          if (!isEffectorMethod) {
+            continue;
+          }
+
+          const configHasTarget = node?.arguments?.[0]?.properties?.some(
+            (prop) => prop?.key.name === "target"
+          );
+          if (!configHasTarget) {
+            continue;
+          }
+
+          const resultAssignedInVariable = traverseParentByType(
+            node,
+            "VariableDeclarator"
+          );
+          const resultPartOfChain = traverseParentByType(
+            node,
+            "ObjectExpression"
+          );
+
+          if (resultAssignedInVariable || resultPartOfChain) {
+            context.report({
+              node,
+              messageId: "ambiguityTarget",
+              data: {
+                methodName: node?.callee?.name,
+              },
+            });
+
+            continue;
+          }
+        }
+      },
+    };
+  },
+};

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

@@ -0,0 +1,12 @@
+# effector/no-ambiguity-target
+
+Call of `gaurd`/`sample` with `target` and variable assignment is ambiguity. One of them should be omitted from source code.
+
+```ts
+// 👎 should be rewritten
+const result = guard({ clock: trigger, filter: Boolean, target });
+
+// 👍 makes sense
+guard({ clock: trigger, filter: Boolean, target });
+const result = target;
+```

package/rules/no-getState/no-getState.js

@@ -1,6 +1,7 @@
 const {
   traverseNestedObjectNode,
 } = require("../../utils/traverse-nested-object-node");
+const { isStoreNameValid } = require("../../utils/is-store-name-valid");
 
 module.exports = {
   meta: {
@@ -17,7 +18,7 @@ module.exports = {
     schema: [],
   },
   create(context) {
-    const parserServices = context.parserServices;
+    const { parserServices } = context;
 
     return {
       CallExpression(node) {
@@ -51,7 +52,7 @@ module.exports = {
         }
         // JavaScript-way
         else {
-          const isEffectorStore = objectName.startsWith("$");
+          const isEffectorStore = isStoreNameValid(objectName, context);
           if (!isEffectorStore) {
             return;
           }

package/rules/no-useless-methods/no-useless-methods.js

@@ -0,0 +1,82 @@
+const {
+  extractImportedFromEffector,
+} = require("../../utils/extract-imported-from-effector");
+const { traverseParentByType } = require("../../utils/traverse-parent-by-type");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbids useless calls of `sample` and `guard`",
+      category: "Quality",
+      recommended: true,
+    },
+    messages: {
+      uselessMethod:
+        "Method `{{ methodName }}` does nothing in this case. You should assign the result to variable or pass `target` to it.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const importedFromEffector = new Map();
+
+    return {
+      ImportDeclaration(node) {
+        extractImportedFromEffector(importedFromEffector, node);
+      },
+      CallExpression(node) {
+        const POSSIBLE_USELESS_METHODS = ["sample", "guard"];
+        for (const method of POSSIBLE_USELESS_METHODS) {
+          const localMethod = importedFromEffector.get(method);
+          if (!localMethod) {
+            continue;
+          }
+
+          const isEffectorMethod = node?.callee?.name === localMethod;
+          if (!isEffectorMethod) {
+            continue;
+          }
+
+          const resultAssignedInVariable = traverseParentByType(
+            node,
+            "VariableDeclarator"
+          );
+          if (resultAssignedInVariable) {
+            continue;
+          }
+
+          const resultReturnedFromFactory = traverseParentByType(
+            node,
+            "ReturnStatement"
+          );
+          if (resultReturnedFromFactory) {
+            continue;
+          }
+
+          const resultPartOfChain = traverseParentByType(
+            node,
+            "ObjectExpression"
+          );
+          if (resultPartOfChain) {
+            continue;
+          }
+
+          const configHasTarget = node?.arguments?.[0]?.properties?.some(
+            (prop) => prop?.key.name === "target"
+          );
+          if (configHasTarget) {
+            continue;
+          }
+
+          context.report({
+            node,
+            messageId: "uselessMethod",
+            data: {
+              methodName: node?.callee?.name,
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-useless-methods/no-useless-methods.md

@@ -0,0 +1,14 @@
+# effector/no-useless-methods
+
+Call of `gaurd`/`sample` without `target` or variable assignment is useless. It can be omitted from source code.
+
+```ts
+// 👎 can be omitted
+guard({ clock: trigger, filter: Boolean });
+
+// 👍 makes sense
+const target1 = guard({ clock: trigger, filter: Boolean });
+
+// 👍 make sense too
+guard({ clock: trigger, filter: Boolean, target: target2 });
+```

package/rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.md

@@ -8,20 +8,20 @@ const eventTwo = createEvent();
 
 // 👎 looks weird
 forward({
-  from: eventOne.map((items) => item.length),
+  from: eventOne.map((items) => items.length),
   to: eventTwo,
 });
 
 // 👎 weird too
 forward({
   from: eventOne,
-  to: eventTwo.prepend((items) => item.length),
+  to: eventTwo.prepend((items) => items.length),
 });
 
 // 👍 better
 sample({
   source: eventOne,
-  fn: (items) => item.length,
+  fn: (items) => items.length,
   target: eventTwo,
 });
 ```

package/utils/get-corrected-store-name.js

@@ -0,0 +1,23 @@
+const { getStoreNameConvention } = require("./get-store-name-convention");
+
+function getCorrectedStoreName(storeName, context) {
+    const storeNameConvention = getStoreNameConvention(context);
+
+    // handle edge case
+    if (storeName.startsWith("$") && storeName.endsWith("$")) {
+
+        if (storeNameConvention === "prefix") {
+            return `$${storeName.slice(0, -1)}`;
+        } else {
+            return `${storeName.slice(1)}$`;
+        }
+    }
+
+    const correctedStoreName = storeNameConvention === "prefix"
+        ? `$${storeName}`
+        : `${storeName}$`;
+
+    return correctedStoreName;
+}
+
+module.exports = { getCorrectedStoreName };

package/utils/get-store-name-convention.js

@@ -0,0 +1,6 @@
+function getStoreNameConvention(context) {
+    // prefix convention is default
+    return context.settings.effector?.storeNameConvention || "prefix";
+}
+
+module.exports = { getStoreNameConvention };

package/utils/is-store-name-valid.js

@@ -0,0 +1,22 @@
+const { getStoreNameConvention } = require("./get-store-name-convention");
+
+function isStoreNameValid(storeName, context) {
+    const storeNameConvention = getStoreNameConvention(context);
+
+    // validate edge case
+    if (storeName?.startsWith("$") && storeName?.endsWith("$")) {
+        return false
+    }
+
+    if (storeNameConvention === "prefix" && storeName?.startsWith("$")) {
+        return true;
+    }
+
+    if (storeNameConvention === "postfix" && storeName?.endsWith("$")) {
+        return true;
+    }
+
+    return false;
+}
+
+module.exports = { isStoreNameValid };

package/utils/traverse-parent-by-type.js

@@ -0,0 +1,13 @@
+function traverseParentByType(node, type) {
+  if (!node) {
+    return null;
+  }
+
+  if (node.type === type) {
+    return node;
+  }
+
+  return traverseParentByType(node.parent, type);
+}
+
+module.exports = { traverseParentByType };

package/utils/validate-store-name-convention.js

@@ -0,0 +1,13 @@
+const { getStoreNameConvention } = require("./get-store-name-convention");
+
+function validateStoreNameConvention(context) {
+    const storeNameConvention = getStoreNameConvention(context);
+
+    if (storeNameConvention !== "prefix" && storeNameConvention !== "postfix") {
+        throw new Error(
+            "Invalid Configuration of effector-plugin-eslint/enforce-store-naming-convention. The value should be equal to prefix or postfix."
+        );
+    }
+}
+
+module.exports = { validateStoreNameConvention };