eslint-plugin-effector 0.5.2 → 0.7.1

package/rules/no-unnecessary-duplication/no-unnecessary-duplication.js

@@ -1,6 +1,8 @@
 const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { areNodesSameInText } = require("../../utils/are-nodes-same-in-text");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { buildObjectInText } = require("../../utils/builders");
+const { method } = require("../../utils/method");
 
 module.exports = {
   meta: {
@@ -32,45 +34,41 @@ module.exports = {
         });
       },
       CallExpression(node) {
-        const METHODS_WITH_POSSIBLE_DUPLCATION = ["sample", "guard"];
-        for (const method of METHODS_WITH_POSSIBLE_DUPLCATION) {
-          const localMethod = importedFromEffector.get(method);
-          if (!localMethod) {
-            continue;
-          }
-
-          const isEffectorMethod = node?.callee?.name === localMethod;
-          if (!isEffectorMethod) {
-            continue;
-          }
-
-          const params = {
-            source: node?.arguments?.[0]?.properties?.find(
-              (n) => n.key.name === "source"
-            ),
-            clock: node?.arguments?.[0]?.properties?.find(
-              (n) => n.key.name === "clock"
-            ),
-          };
-          if (!params.source || !params.clock) {
-            return;
-          }
+        if (
+          method.isNot(["sample", "guard"], {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
 
-          const sameSourceAndClock = areNodesSameInText({
-            context,
-            nodes: [params.source?.value, params.clock?.value],
-          });
-          if (!sameSourceAndClock) {
-            return;
-          }
+        const params = {
+          source: node?.arguments?.[0]?.properties?.find(
+            (n) => n.key.name === "source"
+          ),
+          clock: node?.arguments?.[0]?.properties?.find(
+            (n) => n.key.name === "clock"
+          ),
+        };
+        if (!params.source || !params.clock) {
+          return;
+        }
 
-          reportUnnecessaryDuplication({
-            context,
-            node,
-            params,
-            firstArgument: node?.arguments?.[0],
-          });
+        const sameSourceAndClock = areNodesSameInText({
+          context,
+          nodes: [params.source?.value, params.clock?.value],
+        });
+        if (!sameSourceAndClock) {
+          return;
         }
+
+        reportUnnecessaryDuplication({
+          context,
+          node,
+          params,
+          firstArgument: node?.arguments?.[0],
+        });
       },
     };
   },
@@ -86,11 +84,8 @@ function reportUnnecessaryDuplication({
     const properties = objectNode?.properties?.filter?.(
       (p) => p !== paramToExcludeNode
     );
-    const newPropertiesText = properties
-      .map((p) => context.getSourceCode().getText(p))
-      .join(", ");
 
-    return `{ ${newPropertiesText} }`;
+    return buildObjectInText.fromArrayOfNodes({ properties, context });
   }
 
   context.report({

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

@@ -1,6 +1,7 @@
 const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { traverseParentByType } = require("../../utils/traverse-parent-by-type");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
 
 module.exports = {
   meta: {
@@ -29,67 +30,63 @@ module.exports = {
         });
       },
       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(
+        if (
+          method.isNot(["sample", "guard"], {
             node,
-            "VariableDeclarator"
-          );
-          if (resultAssignedInVariable) {
-            continue;
-          }
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
 
-          const resultReturnedFromFactory = traverseParentByType(
-            node,
-            "ReturnStatement"
-          );
-          if (resultReturnedFromFactory) {
-            continue;
-          }
+        const resultAssignedInVariable = traverseParentByType(
+          node,
+          "VariableDeclarator"
+        );
+        if (resultAssignedInVariable) {
+          return;
+        }
 
-          const resultPartOfChain = traverseParentByType(
-            node,
-            "ObjectExpression"
-          );
-          if (resultPartOfChain) {
-            continue;
-          }
+        const resultReturnedFromFactory = traverseParentByType(
+          node,
+          "ReturnStatement"
+        );
+        if (resultReturnedFromFactory) {
+          return;
+        }
 
-          const configHasTarget = node?.arguments?.[0]?.properties?.some(
-            (prop) => prop?.key.name === "target"
-          );
-          if (configHasTarget) {
-            continue;
-          }
+        const resultPartOfChain = traverseParentByType(
+          node,
+          "ObjectExpression"
+        );
+        if (resultPartOfChain) {
+          return;
+        }
 
-          const resultIsWatched = node?.parent?.property?.name === "watch";
-          if (resultIsWatched) {
-            continue;
-          }
+        const configHasTarget = node?.arguments?.[0]?.properties?.some(
+          (prop) => prop?.key.name === "target"
+        );
+        if (configHasTarget) {
+          return;
+        }
 
-          const resultIsArgument = node?.parent?.type === "CallExpression";
-          if (resultIsArgument) {
-            continue;
-          }
+        const resultIsWatched = node?.parent?.property?.name === "watch";
+        if (resultIsWatched) {
+          return;
+        }
 
-          context.report({
-            node,
-            messageId: "uselessMethod",
-            data: {
-              methodName: node?.callee?.name,
-            },
-          });
+        const resultIsArgument = node?.parent?.type === "CallExpression";
+        if (resultIsArgument) {
+          return;
         }
+
+        context.report({
+          node,
+          messageId: "uselessMethod",
+          data: {
+            methodName: node?.callee?.name,
+          },
+        });
       },
     };
   },

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

@@ -3,6 +3,9 @@ const {
   traverseNestedObjectNode,
 } = require("../../utils/traverse-nested-object-node");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
+const { replaceForwardBySample } = require("../../utils/replace-by-sample");
+const { extractConfig } = require("../../utils/extract-config");
 
 module.exports = {
   meta: {
@@ -18,37 +21,35 @@ module.exports = {
         "Instead of `forward` with `{{ eventName }}.map` you can use `sample`",
       overPrepend:
         "Instead of `forward` with `{{ eventName }}.prepend` you can use `sample`",
+      replaceWithSample: "Repalce `forward` with `sample`.",
     },
     schema: [],
+    hasSuggestions: true,
   },
   create(context) {
+    const importNodes = new Map();
     const importedFromEffector = new Map();
 
     return {
       ImportDeclaration(node) {
         extractImportedFrom({
           importMap: importedFromEffector,
+          nodeMap: importNodes,
           node,
           packageName: "effector",
         });
       },
       CallExpression(node) {
-        const localMethod = importedFromEffector.get("forward");
-        if (!localMethod) {
-          return;
-        }
-
-        const isEffectorMethod = node?.callee?.name === localMethod;
-        if (!isEffectorMethod) {
+        if (
+          method.isNot("forward", {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
           return;
         }
 
-        const forwardConfig = {
-          from: node.arguments?.[0]?.properties.find(
-            (n) => n.key?.name === "from"
-          ),
-          to: node.arguments?.[0]?.properties.find((n) => n.key?.name === "to"),
-        };
+        const forwardConfig = extractConfig(["from", "to"], { node });
 
         if (!forwardConfig.from || !forwardConfig.to) {
           return;
@@ -72,14 +73,25 @@ module.exports = {
             return;
           }
 
-          // console.log(eventName);
-
           context.report({
             node,
             messageId,
             data: {
               eventName,
             },
+            suggest: [
+              {
+                messageId: "replaceWithSample",
+                *fix(fixer) {
+                  yield* replaceForwardBySample(forwardConfig, {
+                    fixer,
+                    node,
+                    context,
+                    importNodes,
+                  });
+                },
+              },
+            ],
           });
         }
 

package/utils/builders.js

@@ -0,0 +1,19 @@
+const buildObjectInText = {
+  fromArrayOfNodes({ properties, context }) {
+    const content = properties
+      .map((property) => context.getSourceCode().getText(property))
+      .join(", ");
+
+    return `{ ${content} }`;
+  },
+  fromMapOfNodes({ properties, context }) {
+    const content = Object.entries(properties)
+      .filter(([_, node]) => Boolean(node))
+      .map(([key, node]) => `${key}: ${context.getSourceCode().getText(node)}`)
+      .join(", ");
+
+    return `{ ${content} }`;
+  },
+};
+
+module.exports = { buildObjectInText };

package/utils/extract-config.js

@@ -0,0 +1,13 @@
+function extractConfig(fields, { node }) {
+  const config = {};
+
+  fields.forEach((field) => {
+    config[field] = node.arguments?.[0]?.properties.find(
+      (n) => n.key?.name === field
+    );
+  });
+
+  return config;
+}
+
+module.exports = { extractConfig };

package/utils/extract-imported-from.js

@@ -1,7 +1,8 @@
-function extractImportedFrom({ importMap, node, packageName }) {
+function extractImportedFrom({ importMap, nodeMap, node, packageName }) {
   if (node.source.value === packageName) {
     for (const s of node.specifiers) {
       importMap.set(s.imported.name, s.local.name);
+      nodeMap?.set(s.imported.name, s);
     }
   }
 }

package/utils/method.js

@@ -0,0 +1,23 @@
+function isSomeMethod(methodName, { node, importMap }) {
+  const normalizedMethodNames = Array.isArray(methodName)
+    ? methodName
+    : [methodName];
+
+  return normalizedMethodNames.some((method) => {
+    const localMethod = importMap.get(method);
+    if (!localMethod) {
+      return false;
+    }
+
+    const isEffectorMethod = node?.callee?.name === localMethod;
+
+    return isEffectorMethod;
+  });
+}
+
+const method = {
+  is: (...args) => isSomeMethod(...args),
+  isNot: (...args) => !isSomeMethod(...args),
+};
+
+module.exports = { method };

package/utils/node-type-is.js

@@ -32,6 +32,21 @@ const nodeTypeIs = {
     }),
   gate: (opts) =>
     hasType({ ...opts, possibleTypes: ["Gate"], from: "effector-react" }),
+  effectorReactHook: (opts) =>
+    hasType({
+      ...opts,
+      possibleTypes: opts.hook
+        ? [].concat(opts.hook)
+        : [
+            "useStore",
+            "useStoreMap",
+            "useList",
+            "useEvent",
+            "useGate",
+            "useUnit",
+          ],
+      from: "effector-react",
+    }),
   not: {
     effect: (opts) =>
       !hasType({
@@ -51,6 +66,7 @@ const nodeTypeIs = {
       }),
     gate: (opts) =>
       !hasType({ ...opts, possibleTypes: ["Gate"], from: "effector-react" }),
+    effectorReactHook: (opts) => !nodeTypeIs.effectorReactHook(opts),
   },
 };
 

package/utils/react.js

@@ -0,0 +1,184 @@
+// borrowed from
+// https://github.com/facebook/react/blob/main/packages/eslint-plugin-react-hooks/src/RulesOfHooks.js
+
+/**
+ * Catch all identifiers that begin with "use" followed by an uppercase Latin
+ * character to exclude identifiers like "user".
+ */
+
+function isHookName(s) {
+  return /^use[A-Z0-9].*$/.test(s);
+}
+
+/**
+ * We consider hooks to be a hook name identifier or a member expression
+ * containing a hook name.
+ */
+
+function isHook(node) {
+  if (node.type === "Identifier") {
+    return isHookName(node.name);
+  } else if (
+    node.type === "MemberExpression" &&
+    !node.computed &&
+    isHook(node.property)
+  ) {
+    const obj = node.object;
+    const isPascalCaseNameSpace = /^[A-Z].*/;
+    return obj.type === "Identifier" && isPascalCaseNameSpace.test(obj.name);
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Checks if the node is a React component name. React component names must
+ * always start with a non-lowercase letter. So `MyComponent` or `_MyComponent`
+ * are valid component names for instance.
+ */
+function isComponentName(node) {
+  if (node.type === "Identifier") {
+    return !/^[a-z]/.test(node.name);
+  } else {
+    return false;
+  }
+}
+
+function isReactFunction(node, functionName) {
+  return (
+    node.name === functionName ||
+    (node.type === "MemberExpression" &&
+      node.object.name === "React" &&
+      node.property.name === functionName)
+  );
+}
+
+/**
+ * Checks if the node is a callback argument of forwardRef. This render function
+ * should follow the rules of hooks.
+ */
+
+function isForwardRefCallback(node) {
+  return !!(
+    node.parent &&
+    node.parent.callee &&
+    isReactFunction(node.parent.callee, "forwardRef")
+  );
+}
+
+/**
+ * Checks if the node is a callback argument of React.memo. This anonymous
+ * functional component should follow the rules of hooks.
+ */
+
+function isMemoCallback(node) {
+  return !!(
+    node.parent &&
+    node.parent.callee &&
+    isReactFunction(node.parent.callee, "memo")
+  );
+}
+
+function isInsideReactComponent(node) {
+  while (node) {
+    const functionName = getFunctionName(node);
+    if (functionName) {
+      if (isComponentName(functionName) || isHook(functionName)) {
+        return true;
+      }
+    }
+    if (isForwardRefCallback(node) || isMemoCallback(node)) {
+      return true;
+    }
+    node = node.parent;
+  }
+  return false;
+}
+
+function isInsideReactHook(node) {
+  while (node) {
+    const functionName = getFunctionName(node);
+    if (functionName) {
+      if (isHook(functionName)) {
+        return true;
+      }
+    }
+    node = node.parent;
+  }
+  return false;
+}
+
+module.exports = {
+  isInsideReactComponent,
+  isInsideReactHook,
+};
+
+/**
+ * Gets the static name of a function AST node. For function declarations it is
+ * easy. For anonymous function expressions it is much harder. If you search for
+ * `IsAnonymousFunctionDefinition()` in the ECMAScript spec you'll find places
+ * where JS gives anonymous function expressions names. We roughly detect the
+ * same AST nodes with some exceptions to better fit our use case.
+ */
+
+function getFunctionName(node) {
+  if (
+    node.type === "FunctionDeclaration" ||
+    (node.type === "FunctionExpression" && node.id)
+  ) {
+    // function useHook() {}
+    // const whatever = function useHook() {};
+    //
+    // Function declaration or function expression names win over any
+    // assignment statements or other renames.
+    return node.id;
+  } else if (
+    node.type === "FunctionExpression" ||
+    node.type === "ArrowFunctionExpression"
+  ) {
+    if (
+      node.parent.type === "VariableDeclarator" &&
+      node.parent.init === node
+    ) {
+      // const useHook = () => {};
+      return node.parent.id;
+    } else if (
+      node.parent.type === "AssignmentExpression" &&
+      node.parent.right === node &&
+      node.parent.operator === "="
+    ) {
+      // useHook = () => {};
+      return node.parent.left;
+    } else if (
+      node.parent.type === "Property" &&
+      node.parent.value === node &&
+      !node.parent.computed
+    ) {
+      // {useHook: () => {}}
+      // {useHook() {}}
+      return node.parent.key;
+
+      // NOTE: We could also support `ClassProperty` and `MethodDefinition`
+      // here to be pedantic. However, hooks in a class are an anti-pattern. So
+      // we don't allow it to error early.
+      //
+      // class {useHook = () => {}}
+      // class {useHook() {}}
+    } else if (
+      node.parent.type === "AssignmentPattern" &&
+      node.parent.right === node &&
+      !node.parent.computed
+    ) {
+      // const {useHook = () => {}} = {};
+      // ({useHook = () => {}} = {});
+      //
+      // Kinda clowny, but we'd said we'd follow spec convention for
+      // `IsAnonymousFunctionDefinition()` usage.
+      return node.parent.left;
+    } else {
+      return undefined;
+    }
+  } else {
+    return undefined;
+  }
+}

package/utils/read-example.js

@@ -1,8 +1,45 @@
 const { readFileSync } = require("fs");
 const { join } = require("path");
+const glob = require("glob");
 
 function readExample(dirname, exampleName) {
   return readFileSync(join(dirname, "examples", exampleName)).toString();
 }
 
-module.exports = { readExample };
+function getCorrectExamples(dirname, config = {}) {
+  const { ext = "js", namesOnly = true } = config;
+  const pattern = `correct-*.${ext}`;
+  const correct = glob.sync(join(dirname, "examples", pattern));
+
+  let result = correct;
+
+  if (namesOnly) {
+    result = result.map((path) => {
+      const rightSlashIdx = path.lastIndexOf("/");
+
+      return path.slice(rightSlashIdx + 1);
+    });
+  }
+
+  return result;
+}
+
+function getIncorrectExamples(dirname, config = {}) {
+  const { ext = "js", namesOnly = true } = config;
+  const pattern = `incorrect-*.${ext}`;
+  const incorrect = glob.sync(join(dirname, "examples", pattern));
+
+  let result = incorrect;
+
+  if (namesOnly) {
+    result = result.map((path) => {
+      const rightSlashIdx = path.lastIndexOf("/");
+
+      return path.slice(rightSlashIdx + 1);
+    });
+  }
+
+  return result;
+}
+
+module.exports = { readExample, getCorrectExamples, getIncorrectExamples };