eslint-plugin-remeda 1.0.0

package/src/rules/collection-method-value.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Rule to enforce usage of collection method values
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const getDocsUrl = require("../util/getDocsUrl");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    schema: [],
+    docs: {
+      url: getDocsUrl("collection-method-value"),
+    },
+  },
+
+  create(context) {
+    const {
+      isChainBreaker,
+      getRemedaMethodVisitors,
+      isCallToMethod,
+    } = require("../util/lodashUtil");
+    const { getMethodName } = require("../util/astUtil");
+    const {
+      isCollectionMethod,
+      isAliasOfMethod,
+      getSideEffectIterationMethods,
+    } = require("../util/methodDataUtil");
+    const includes = require("lodash/includes");
+
+    function parentUsesValue(node, callType) {
+      const isBeforeChainBreaker =
+        callType === "chained" && isChainBreaker(node.parent.parent);
+      return (
+        (isBeforeChainBreaker ? node.parent.parent : node).parent.type !==
+        "ExpressionStatement"
+      );
+    }
+
+    function isPureRemedaCollectionMethod(method) {
+      return isCollectionMethod(method) && !isAliasOfMethod("remove", method);
+    }
+
+    function isSideEffectIterationMethod(method) {
+      return includes(getSideEffectIterationMethods(), method);
+    }
+
+    function isParentCommit(node, callType) {
+      return (
+        callType === "chained" && isCallToMethod(node.parent.parent, "commit")
+      );
+    }
+
+    return getRemedaMethodVisitors(
+      context,
+      (node, iteratee, { method, callType }) => {
+        if (
+          isPureRemedaCollectionMethod(method) &&
+          !parentUsesValue(node, callType)
+        ) {
+          context.report({
+            node,
+            message: `Use value returned from R.${method}`,
+          });
+        } else if (
+          isSideEffectIterationMethod(method) &&
+          parentUsesValue(node, callType) &&
+          !isParentCommit(node, callType)
+        ) {
+          context.report({
+            node,
+            message: `Do not use value returned from R.${getMethodName(node)}`,
+          });
+        }
+      },
+    );
+  },
+};

package/src/rules/collection-return.js

@@ -0,0 +1,71 @@
+/**
+ * @fileoverview Rule to check that iteratees for all collection functions except forEach return a value;
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const getDocsUrl = require("../util/getDocsUrl");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    schema: [],
+    docs: {
+      url: getDocsUrl("collection-return"),
+    },
+  },
+
+  create(context) {
+    const {
+      getRemedaMethodCallExpVisitor,
+      getLodashContext,
+    } = require("../util/lodashUtil");
+    const { isCollectionMethod } = require("../util/methodDataUtil");
+    const { isFunctionDefinitionWithBlock } = require("../util/astUtil");
+    const assign = require("lodash/assign");
+    const funcInfos = new Map();
+    let currFuncInfo = {};
+    const lodashContext = getLodashContext(context);
+    return assign(
+      {
+        "CallExpression:exit": getRemedaMethodCallExpVisitor(
+          lodashContext,
+          (node, iteratee, { method }) => {
+            if (isCollectionMethod(method) && funcInfos.has(iteratee)) {
+              const { hasReturn } = funcInfos.get(iteratee);
+              if (
+                isFunctionDefinitionWithBlock(iteratee) &&
+                !hasReturn &&
+                !iteratee.async &&
+                !iteratee.generator
+              ) {
+                context.report({
+                  node,
+                  message: `Do not use R.${method} without returning a value`,
+                });
+              }
+            }
+          },
+        ),
+        ReturnStatement() {
+          currFuncInfo.hasReturn = true;
+        },
+        onCodePathStart(codePath, node) {
+          currFuncInfo = {
+            upper: currFuncInfo,
+            codePath,
+            hasReturn: false,
+          };
+          funcInfos.set(node, currFuncInfo);
+        },
+        onCodePathEnd() {
+          currFuncInfo = currFuncInfo.upper;
+        },
+      },
+      lodashContext.getImportVisitors(),
+    );
+  },
+};

package/src/rules/prefer-constant.js

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview Rule to check if the expression could be better expressed as a R.constant
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const getDocsUrl = require("../util/getDocsUrl");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      url: getDocsUrl("prefer-constant"),
+    },
+    schema: [
+      {
+        type: "boolean",
+      },
+      {
+        type: "boolean",
+      },
+    ],
+  },
+
+  create(context) {
+    const { getValueReturnedInFirstStatement } = require("../util/astUtil");
+    const shouldCheckArrowFunctions =
+      context.options[0] !== undefined ? context.options[0] : true;
+    const shouldCheckFunctionDeclarations =
+      context.options[1] !== undefined ? context.options[1] : false;
+
+    function isCompletelyLiteral(node) {
+      switch (node.type) {
+        case "Literal":
+          return true;
+        case "BinaryExpression":
+          return (
+            isCompletelyLiteral(node.left) && isCompletelyLiteral(node.right)
+          );
+        case "UnaryExpression":
+          return isCompletelyLiteral(node.argument);
+        case "ConditionalExpression":
+          return (
+            isCompletelyLiteral(node.test) &&
+            isCompletelyLiteral(node.consequent) &&
+            isCompletelyLiteral(node.alternate)
+          );
+        default:
+          return false;
+      }
+    }
+
+    function reportIfLikeConstant(func, node) {
+      const valueReturnedInFirstLine = func(node);
+      if (
+        valueReturnedInFirstLine &&
+        isCompletelyLiteral(valueReturnedInFirstLine)
+      ) {
+        context.report({
+          node,
+          message: "Prefer R.constant over a function returning a literal",
+        });
+      }
+    }
+
+    function handleFunctionDefinition(node) {
+      reportIfLikeConstant(getValueReturnedInFirstStatement, node);
+    }
+
+    return {
+      FunctionExpression: handleFunctionDefinition,
+      FunctionDeclaration(node) {
+        if (shouldCheckFunctionDeclarations) {
+          handleFunctionDefinition(node);
+        }
+      },
+      ArrowFunctionExpression(node) {
+        if (shouldCheckArrowFunctions) {
+          handleFunctionDefinition(node);
+        }
+      },
+    };
+  },
+};

package/src/rules/prefer-do-nothing.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Rule to prefer R.doNothing() or R.constant(undefined) over an empty function
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const getDocsUrl = require("../util/getDocsUrl");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    schema: [],
+    docs: {
+      url: getDocsUrl("prefer-do-nothing"),
+    },
+  },
+
+  create(context) {
+    const { getFirstFunctionLine } = require("../util/astUtil");
+
+    function reportIfEmptyFunction(node) {
+      if (
+        !getFirstFunctionLine(node) &&
+        node.parent.type !== "MethodDefinition" &&
+        !node.generator &&
+        !node.async
+      ) {
+        context.report({
+          node,
+          message:
+            "Prefer R.doNothing() or R.constant(undefined) over an empty function",
+        });
+      }
+    }
+
+    return {
+      FunctionExpression: reportIfEmptyFunction,
+      ArrowFunctionExpression: reportIfEmptyFunction,
+    };
+  },
+};

package/src/rules/prefer-filter.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Rule to check if a call to R.forEach should be a call to R.filter
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const getDocsUrl = require("../util/getDocsUrl");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      url: getDocsUrl("prefer-filter"),
+    },
+    schema: [
+      {
+        type: "integer",
+      },
+    ],
+  },
+
+  create(context) {
+    const { getRemedaMethodVisitors } = require("../util/lodashUtil");
+    const {
+      isIdentifierWithName,
+      isMemberExpOf,
+      isNegationOfMemberOf,
+      isEqEqEqToMemberOf,
+      isNotEqEqToMemberOf,
+      getFirstFunctionLine,
+      hasOnlyOneStatement,
+      getFirstParamName,
+    } = require("../util/astUtil");
+    const { isAliasOfMethod } = require("../util/methodDataUtil");
+    const DEFAULT_MAX_PROPERTY_PATH_LENGTH = 3;
+    const maxLength =
+      parseInt(context.options[0], 10) || DEFAULT_MAX_PROPERTY_PATH_LENGTH;
+
+    function isIfWithoutElse(statement) {
+      return (
+        statement && statement.type === "IfStatement" && !statement.alternate
+      );
+    }
+
+    function canBeShorthand(exp, paramName) {
+      return (
+        isIdentifierWithName(exp, paramName) ||
+        isMemberExpOf(exp, paramName, { maxLength }) ||
+        isNegationOfMemberOf(exp, paramName, { maxLength }) ||
+        isEqEqEqToMemberOf(exp, paramName, { maxLength }) ||
+        isNotEqEqToMemberOf(exp, paramName, { maxLength })
+      );
+    }
+
+    function onlyHasSimplifiableIf(func) {
+      const firstLine = getFirstFunctionLine(func);
+      return (
+        func &&
+        hasOnlyOneStatement(func) &&
+        func.params.length === 1 &&
+        isIfWithoutElse(firstLine) &&
+        canBeShorthand(firstLine.test, getFirstParamName(func))
+      );
+    }
+
+    return getRemedaMethodVisitors(context, (node, iteratee, { method }) => {
+      if (
+        isAliasOfMethod("forEach", method) &&
+        onlyHasSimplifiableIf(iteratee)
+      ) {
+        context.report({
+          node,
+          message:
+            "Prefer R.filter or R.some over an if statement inside a R.forEach",
+        });
+      }
+    });
+  },
+};

package/src/rules/prefer-find.js

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Rule to check if a call to `R.filter` should be a call to `R.find`.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const getDocsUrl = require("../util/getDocsUrl");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    schema: [],
+    docs: {
+      url: getDocsUrl("prefer-find"),
+    },
+  },
+
+  create(context) {
+    const {
+      getRemedaMethodVisitors,
+      isCallToMethod,
+      isCallToLodashMethod,
+    } = require("../util/lodashUtil");
+    const { isAliasOfMethod } = require("../util/methodDataUtil");
+
+    function isZeroIndexAccess(node) {
+      return node.type === "MemberExpression" && node.property.value === 0;
+    }
+
+    function isChainedBeforeMethod(callType, node, method) {
+      return (
+        callType === "chained" && isCallToMethod(node.parent.parent, method)
+      );
+    }
+
+    return getRemedaMethodVisitors(
+      context,
+      (node, iteratee, { method, callType, lodashContext }) => {
+        if (isAliasOfMethod("filter", method)) {
+          if (
+            isZeroIndexAccess(node.parent) ||
+            isCallToLodashMethod(node.parent, "first", lodashContext) ||
+            isChainedBeforeMethod(callType, node, "first")
+          ) {
+            context.report({
+              node,
+              message:
+                "Prefer using `R.find` over selecting the first item of a filtered result",
+            });
+          }
+          if (
+            isCallToLodashMethod(node.parent, "last", lodashContext) ||
+            isChainedBeforeMethod(callType, node, "last")
+          ) {
+            context.report({
+              node,
+              message:
+                "Prefer using `R.findLast` over selecting the last item of a filtered result",
+            });
+          }
+        }
+      },
+    );
+  },
+};

package/src/rules/prefer-flat-map.js

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Rule to check if a call to map and flatten should be a call to R.flatMap
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const getDocsUrl = require("../util/getDocsUrl");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    schema: [],
+    docs: {
+      url: getDocsUrl("prefer-flat-map"),
+    },
+  },
+
+  create(context) {
+    const {
+      getRemedaMethodVisitors,
+      isCallToMethod,
+      isCallToLodashMethod,
+    } = require("../util/lodashUtil");
+    const { getCaller } = require("../util/astUtil");
+    const { isAliasOfMethod } = require("../util/methodDataUtil");
+
+    function isChainedMapFlatten(callType, node) {
+      return callType === "chained" && isCallToMethod(getCaller(node), "map");
+    }
+
+    return getRemedaMethodVisitors(
+      context,
+      (node, iteratee, { method, callType, lodashContext }) => {
+        if (
+          isAliasOfMethod("flatten", method) &&
+          (isChainedMapFlatten(callType, node) ||
+            isCallToLodashMethod(node.arguments[0], "map", lodashContext))
+        ) {
+          context.report({
+            node,
+            message: "Prefer R.flatMap over consecutive map and flatten.",
+          });
+        }
+      },
+    );
+  },
+};

package/src/rules/prefer-is-empty.js

@@ -0,0 +1,134 @@
+/**
+ * @fileoverview Rule to prefer isEmpty over manually checking for length value.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const getDocsUrl = require("../util/getDocsUrl");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    schema: [],
+    docs: {
+      url: getDocsUrl("prefer-is-empty"),
+    },
+    fixable: "code",
+  },
+
+  create(context) {
+    const { getLodashContext } = require("../util/lodashUtil");
+    const lodashContext = getLodashContext(context);
+
+    function getTextOfNode(node) {
+      if (node) {
+        if (node.type === "Identifier") {
+          return node.name;
+        }
+        return context.getSourceCode().getText(node);
+      }
+    }
+
+    const visitors = lodashContext.getImportVisitors();
+    visitors.BinaryExpression = function (node) {
+      if (node.operator === "===") {
+        if (node.left) {
+          if (node.left.property && node.right) {
+            const leftExpressionMember = node.left.property.name;
+            const rightExpressionMember = node.right.value;
+            if (
+              leftExpressionMember === "length" &&
+              rightExpressionMember === 0
+            ) {
+              const subjectObject = node.left.object;
+              context.report({
+                node,
+                message:
+                  "Prefer isEmpty over manually checking for length value.",
+                fix(fixer) {
+                  return fixer.replaceText(
+                    node,
+                    `isEmpty(${getTextOfNode(subjectObject)})`
+                  );
+                },
+              });
+            }
+          } else if (
+            node.left.expression &&
+            node.right &&
+            node.left.expression.property
+          ) {
+            const leftExpressionMember = node.left.expression.property.name;
+            const rightExpressionMember = node.right.value;
+            if (
+              leftExpressionMember === "length" &&
+              rightExpressionMember === 0
+            ) {
+              const subjectObject = node.left.expression.object;
+              context.report({
+                node,
+                message:
+                  "Prefer isEmpty over manually checking for length value.",
+                fix(fixer) {
+                  return fixer.replaceText(
+                    node,
+                    `isEmpty(${getTextOfNode(subjectObject)})`
+                  );
+                },
+              });
+            }
+          }
+        }
+      }
+      if (node.operator === ">") {
+        if (node.left) {
+          if (node.left.property && node.right) {
+            const leftExpressionMember = node.left.property.name;
+            const rightExpressionMember = node.right.value;
+            if (
+              leftExpressionMember === "length" &&
+              rightExpressionMember === 0
+            ) {
+              const subjectObject = node.left.object;
+              context.report({
+                node,
+                message:
+                  "Prefer isEmpty over manually checking for length value.",
+                fix(fixer) {
+                  return fixer.replaceText(
+                    node,
+                    `!isEmpty(${getTextOfNode(subjectObject)})`
+                  );
+                },
+              });
+            }
+          } else if (node.left.expression && node.right) {
+            const leftExpressionMember = node.left.expression.property.name;
+            const rightExpressionMember = node.right.value;
+            if (
+              leftExpressionMember === "length" &&
+              rightExpressionMember === 0
+            ) {
+              const subjectObject = node.left.expression.object;
+              context.report({
+                node,
+                message:
+                  "Prefer isEmpty over manually checking for length value.",
+                fix(fixer) {
+                  return fixer.replaceText(
+                    node,
+                    `!isEmpty(${getTextOfNode(subjectObject)})`
+                  );
+                },
+              });
+            }
+          }
+        }
+      }
+    };
+    return visitors;
+  },
+};