eslint-plugin-effector 0.16.0 → 0.18.0

package/rules/no-guard/no-guard.js

@@ -1,78 +0,0 @@
-const { extractImportedFrom } = require("../../utils/extract-imported-from");
-const { createLinkToRule } = require("../../utils/create-link-to-rule");
-const { method } = require("../../utils/method");
-const { replaceGuardBySample } = require("../../utils/replace-by-sample");
-const { extractConfig } = require("../../utils/extract-config");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Prefer `sample` over `guard`",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("no-guard"),
-    },
-    messages: {
-      noGuard:
-        "Instead of `guard` you can use `sample`, it is more extendable.",
-      replaceWithSample: "Replace `guard` 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) {
-        if (
-          method.isNot("guard", {
-            node,
-            importMap: importedFromEffector,
-          })
-        ) {
-          return;
-        }
-
-        const guardConfig = extractConfig(
-          ["source", "clock", "target", "filter"],
-          {
-            node,
-          }
-        );
-
-        if (!guardConfig.clock || !guardConfig.filter) {
-          return;
-        }
-
-        context.report({
-          messageId: "noGuard",
-          node,
-          suggest: [
-            {
-              messageId: "replaceWithSample",
-              *fix(fixer) {
-                yield* replaceGuardBySample(guardConfig, {
-                  fixer,
-                  node,
-                  context,
-                  importNodes,
-                });
-              },
-            },
-          ],
-        });
-      },
-    };
-  },
-};

package/rules/no-patronum-debug/no-patronum-debug.js

@@ -1,133 +0,0 @@
-const { createLinkToRule } = require("../../utils/create-link-to-rule");
-const { extractImportedFrom } = require("../../utils/extract-imported-from");
-
-module.exports = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Disallow the use of patronum `debug`",
-      category: "Quality",
-      recommended: false,
-      url: createLinkToRule("no-patronum-debug"),
-    },
-    messages: {
-      noPatronumDebug: "Unexpected patronum `debug` statement",
-      removePatronumDebug: "Remove this `debug` from patronum",
-    },
-    schema: [],
-    hasSuggestions: true,
-  },
-  create(context) {
-    const importedFromPatronum = new Map();
-    const importNodes = new Map();
-
-    return {
-      ImportDeclaration(node) {
-        extractImportedFrom({
-          packageName: ["patronum", "patronum/debug"],
-          importMap: importedFromPatronum,
-          nodeMap: importNodes,
-          node,
-        });
-      },
-      CallExpression(node) {
-        const currentMethod = node?.callee?.name ?? node?.callee?.object?.name;
-        const importedDebugFromPatronum = importedFromPatronum.get("debug");
-
-        if (
-          !importedDebugFromPatronum ||
-          currentMethod !== importedDebugFromPatronum
-        ) {
-          return;
-        }
-
-        context.report({
-          messageId: "noPatronumDebug",
-          node,
-          suggest: [
-            {
-              messageId: "removePatronumDebug",
-              *fix(fixer) {
-                yield* removeDebugFromPatronum({
-                  fixer,
-                  node,
-                  context,
-                  importNodes,
-                });
-              },
-            },
-          ],
-        });
-      },
-    };
-  },
-};
-
-function* removeDebugFromPatronum({
-  fixer,
-  node,
-  context,
-  importNodes,
-  targetMethod = "debug",
-}) {
-  const sourceCode = context.getSourceCode();
-  const startToken = sourceCode.getTokenBefore(node);
-
-  // remove line with debug
-  yield fixer.removeRange([startToken.range[1], node.range[1]]);
-  const semi = sourceCode.getTokenBefore(node, {
-    filter: (token) => token.value === ";",
-  });
-
-  if (semi) yield fixer.remove(semi);
-
-  const importDebugNode = importNodes.get(targetMethod);
-
-  if (!importDebugNode) {
-    return null;
-  }
-
-  // remove import with debug
-  const importParentNode = importDebugNode.parent;
-  const amountImportFromPatronum = importParentNode.specifiers.length;
-
-  /**
-   * import { debug } from 'patronum'
-   * import { debug } from 'patronum/debug'
-   */
-  if (amountImportFromPatronum === 1) {
-    yield fixer.removeRange([
-      importParentNode.range[0],
-      importParentNode.range[1] + 1,
-    ]);
-
-    return null;
-  }
-
-  const importLast = importParentNode.specifiers[amountImportFromPatronum - 1];
-  const filterTokenComma = { filter: (token) => token.value === "," };
-
-  /**
-   * import { debug, timeout } from 'patronum'
-   * import { condition, debug, throttle } from 'patronum'
-   */
-  if (importDebugNode !== importLast) {
-    const prevNode = sourceCode.getTokenBefore(importDebugNode);
-    const comma = sourceCode.getTokenAfter(importDebugNode, filterTokenComma);
-
-    yield fixer.removeRange([prevNode.range[1], importDebugNode.range[0]]);
-    yield fixer.remove(importDebugNode);
-    yield fixer.remove(comma);
-
-    return null;
-  }
-
-  /**
-   * import { condition, debug } from 'patronum'
-   */
-  const comma = sourceCode.getTokenBefore(importDebugNode, filterTokenComma);
-
-  yield fixer.removeRange([comma.range[1], importDebugNode.range[0]]);
-  yield fixer.remove(importDebugNode);
-  yield fixer.remove(comma);
-}

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

@@ -1,88 +0,0 @@
-const { extractImportedFrom } = require("../../utils/extract-imported-from");
-const { createLinkToRule } = require("../../utils/create-link-to-rule");
-const { method } = require("../../utils/method");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Forbids unnecessary combinations in `clock`, `source` and `forward`",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("no-unnecessary-combination"),
-    },
-    messages: {
-      unnecessaryCombination:
-        "Method {{ methodName }} is used under the hood, you can omit it.",
-    },
-    schema: [],
-  },
-  create(context) {
-    const importedFromEffector = new Map();
-
-    return {
-      ImportDeclaration(node) {
-        extractImportedFrom({
-          importMap: importedFromEffector,
-          node,
-          packageName: "effector",
-        });
-      },
-      CallExpression(node) {
-        const CONFIG_ARG_PROPERTIES = ["source", "clock", "from"];
-
-        function toLocalMethod(methodName) {
-          return importedFromEffector.get(methodName);
-        }
-
-        const UNNECESSARY_METHODS = {
-          source: ["combine", "merge"].map(toLocalMethod).filter(Boolean),
-          clock: ["merge"].map(toLocalMethod).filter(Boolean),
-          from: ["merge"].map(toLocalMethod).filter(Boolean),
-        };
-
-        if (
-          method.isNot(["sample", "guard", "forward"], {
-            node,
-            importMap: importedFromEffector,
-          })
-        ) {
-          return;
-        }
-
-        const candidates =
-          node?.arguments?.[0]?.properties?.filter((n) =>
-            CONFIG_ARG_PROPERTIES.includes(n.key.name)
-          ) ?? [];
-
-        if (candidates.length === 0) {
-          return;
-        }
-
-        for (const candidate of candidates) {
-          const candidateName = candidate?.value?.callee?.name;
-          const argProp = candidate?.key?.name;
-          if (!candidateName || !argProp) {
-            continue;
-          }
-
-          const localUnnecessaryMethods = UNNECESSARY_METHODS[argProp];
-
-          const UnnecessaryMethodIsEffectorMethod =
-            localUnnecessaryMethods.some((m) => m === candidateName);
-
-          if (!UnnecessaryMethodIsEffectorMethod) {
-            continue;
-          }
-
-          context.report({
-            node: candidate?.value,
-            messageId: "unnecessaryCombination",
-            data: { methodName: candidateName },
-          });
-        }
-      },
-    };
-  },
-};

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

@@ -1,115 +0,0 @@
-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: {
-    type: "problem",
-    docs: {
-      description: "Forbids unnecessary duplication in `clock` and `source`",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("no-unnecessary-duplication"),
-    },
-    messages: {
-      unnecessaryDuplication:
-        "Same `source` and `clock` can be replaced with only one of them.",
-      removeClock: "Remove `clock`",
-      removeSource: "Remove `source`",
-    },
-    schema: [],
-    hasSuggestions: true,
-  },
-  create(context) {
-    const importedFromEffector = new Map();
-
-    return {
-      ImportDeclaration(node) {
-        extractImportedFrom({
-          importMap: importedFromEffector,
-          node,
-          packageName: "effector",
-        });
-      },
-      CallExpression(node) {
-        if (
-          method.isNot(["sample", "guard"], {
-            node,
-            importMap: importedFromEffector,
-          })
-        ) {
-          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;
-        }
-
-        const sameSourceAndClock = areNodesSameInText({
-          context,
-          nodes: [params.source?.value, params.clock?.value],
-        });
-        if (!sameSourceAndClock) {
-          return;
-        }
-
-        reportUnnecessaryDuplication({
-          context,
-          node,
-          params,
-          firstArgument: node?.arguments?.[0],
-        });
-      },
-    };
-  },
-};
-
-function reportUnnecessaryDuplication({
-  context,
-  node,
-  params,
-  firstArgument,
-}) {
-  function excludeParamFromObjectInText(objectNode, paramToExcludeNode) {
-    const properties = objectNode?.properties?.filter?.(
-      (p) => p !== paramToExcludeNode
-    );
-
-    return buildObjectInText.fromArrayOfNodes({ properties, context });
-  }
-
-  context.report({
-    node,
-    messageId: "unnecessaryDuplication",
-    suggest: [
-      {
-        messageId: "removeClock",
-        fix(fixer) {
-          return fixer.replaceText(
-            firstArgument,
-            excludeParamFromObjectInText(firstArgument, params.clock)
-          );
-        },
-      },
-      {
-        messageId: "removeSource",
-        fix(fixer) {
-          return fixer.replaceText(
-            firstArgument,
-            excludeParamFromObjectInText(firstArgument, params.source)
-          );
-        },
-      },
-    ],
-  });
-}

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

@@ -1,93 +0,0 @@
-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: {
-    type: "problem",
-    docs: {
-      description: "Forbids useless calls of `sample` and `guard`",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("no-useless-methods"),
-    },
-    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) {
-        extractImportedFrom({
-          importMap: importedFromEffector,
-          node,
-          packageName: "effector",
-        });
-      },
-      CallExpression(node) {
-        if (
-          method.isNot(["sample", "guard"], {
-            node,
-            importMap: importedFromEffector,
-          })
-        ) {
-          return;
-        }
-
-        const resultAssignedInVariable = traverseParentByType(
-          node,
-          "VariableDeclarator"
-        );
-        if (resultAssignedInVariable) {
-          return;
-        }
-
-        const resultReturnedFromFactory = traverseParentByType(
-          node,
-          "ReturnStatement"
-        );
-        if (resultReturnedFromFactory) {
-          return;
-        }
-
-        const resultPartOfChain = traverseParentByType(
-          node,
-          "ObjectExpression"
-        );
-        if (resultPartOfChain) {
-          return;
-        }
-
-        const configHasTarget = node?.arguments?.[0]?.properties?.some(
-          (prop) => prop?.key.name === "target"
-        );
-        if (configHasTarget) {
-          return;
-        }
-
-        const resultIsWatched = node?.parent?.property?.name === "watch";
-        if (resultIsWatched) {
-          return;
-        }
-
-        const resultIsArgument = node?.parent?.type === "CallExpression";
-        if (resultIsArgument) {
-          return;
-        }
-
-        context.report({
-          node,
-          messageId: "uselessMethod",
-          data: {
-            methodName: node?.callee?.name,
-          },
-        });
-      },
-    };
-  },
-};

package/rules/no-watch/no-watch.js

@@ -1,61 +0,0 @@
-const { ESLintUtils } = require("@typescript-eslint/utils");
-
-const {
-  traverseNestedObjectNode,
-} = require("../../utils/traverse-nested-object-node");
-const { createLinkToRule } = require("../../utils/create-link-to-rule");
-const { nodeTypeIs } = require("../../utils/node-type-is");
-
-module.exports = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Avoid `.watch` calls on any Effector unit or operator",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("no-watch"),
-    },
-    messages: {
-      abusiveCall:
-        "Method `.watch` leads to imperative code. Try to replace it with operator (`sample`) or use the `target` parameter of the operator.",
-    },
-    schema: [],
-  },
-  create(context) {
-    let parserServices;
-    try {
-      parserServices = ESLintUtils.getParserServices(context);
-    } catch (err) {
-      // no types information
-    }
-
-    if (!parserServices?.program) {
-      // JavaScript-way https://github.com/effector/eslint-plugin/issues/48#issuecomment-931107829
-      return {};
-    }
-
-    return {
-      'CallExpression[callee.property.name="watch"]'(node) {
-        const object = traverseNestedObjectNode(node.callee?.object);
-
-        const isEffectorUnit = nodeTypeIs.unit({
-          node: object,
-          context,
-        });
-
-        if (!isEffectorUnit) {
-          return;
-        }
-
-        reportWatchCall({ context, node });
-      },
-    };
-  },
-};
-
-function reportWatchCall({ context, node }) {
-  context.report({
-    node,
-    messageId: "abusiveCall",
-  });
-}

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

@@ -1,111 +0,0 @@
-const { extractImportedFrom } = require("../../utils/extract-imported-from");
-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: {
-    type: "problem",
-    docs: {
-      description: "Prefer `sample` over `forward` with `.map`/`.prepend`",
-      category: "Quality",
-      recommended: true,
-      url: createLinkToRule("prefer-sample-over-forward-with-mapping"),
-    },
-    messages: {
-      overMap:
-        "Instead of `forward` with `{{ eventName }}.map` you can use `sample`",
-      overPrepend:
-        "Instead of `forward` with `{{ eventName }}.prepend` you can use `sample`",
-      replaceWithSample: "Replace `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) {
-        if (
-          method.isNot("forward", {
-            node,
-            importMap: importedFromEffector,
-          })
-        ) {
-          return;
-        }
-
-        const forwardConfig = extractConfig(["from", "to"], { node });
-
-        if (!forwardConfig.from || !forwardConfig.to) {
-          return;
-        }
-
-        function checkForMapping({ paramNode, methodName, messageId }) {
-          if (paramNode.value?.type !== "CallExpression") {
-            return;
-          }
-
-          if (paramNode.value?.callee?.property?.name !== methodName) {
-            return;
-          }
-
-          const eventNode = traverseNestedObjectNode(
-            paramNode.value?.callee?.object
-          );
-          const eventName = eventNode?.name;
-
-          if (!eventName) {
-            return;
-          }
-
-          context.report({
-            node,
-            messageId,
-            data: {
-              eventName,
-            },
-            suggest: [
-              {
-                messageId: "replaceWithSample",
-                *fix(fixer) {
-                  yield* replaceForwardBySample(forwardConfig, {
-                    fixer,
-                    node,
-                    context,
-                    importNodes,
-                  });
-                },
-              },
-            ],
-          });
-        }
-
-        checkForMapping({
-          paramNode: forwardConfig.from,
-          methodName: "map",
-          messageId: "overMap",
-        });
-        checkForMapping({
-          paramNode: forwardConfig.to,
-          methodName: "prepend",
-          messageId: "overPrepend",
-        });
-      },
-    };
-  },
-};