eslint-plugin-remeda 1.0.0 → 1.2.0

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

@@ -1,134 +0,0 @@
-/**
- * @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;
-  },
-};

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

@@ -1,97 +0,0 @@
-/**
- * @fileoverview Rule to prefer isNil over manual checking for undefined or null.
- */
-'use strict'
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require('../util/getDocsUrl')
-
-module.exports = {
-    meta: {
-        type: 'problem',
-        schema: [],
-        docs: {
-            url: getDocsUrl('prefer-is-nil')
-        }
-    },
-
-    create(context) {
-        const {isNegationExpression, isEquivalentMemberExp} = require('../util/astUtil')
-        const {isCallToLodashMethod, getLodashContext} = require('../util/lodashUtil')
-        const _ = require('lodash')
-        const lodashContext = getLodashContext(context)
-        const nilChecks = {
-            null: {
-                isValue: _.matches({type: 'Literal', value: null}),
-                expressionChecks: [getLodashTypeCheckedBy('isNull'), getValueComparedTo('null')]
-            },
-            undefined: {
-                isValue: _.matches({type: 'Identifier', name: 'undefined'}),
-                expressionChecks: [getLodashTypeCheckedBy('isUndefined'), getValueComparedTo('undefined'), getValueWithTypeofUndefinedComparison]
-            }
-        }
-
-        function getLodashTypeCheckedBy(typecheck) {
-            return function (node) {
-                return isCallToLodashMethod(node, typecheck, lodashContext) && node.arguments[0]
-            }
-        }
-
-        function getValueComparedTo(nil) {
-            return function (node, operator) {
-                return node.type === 'BinaryExpression' && node.operator === operator &&
-                    ((nilChecks[nil].isValue(node.right) && node.left) || (nilChecks[nil].isValue(node.left) && node.right))
-            }
-        }
-
-
-        const getTypeofArgument = _.cond([
-            [_.matches({type: 'UnaryExpression', operator: 'typeof'}), _.property('argument')]
-        ])
-
-        const isUndefinedString = _.matches({type: 'Literal', value: 'undefined'})
-
-        function getValueWithTypeofUndefinedComparison(node, operator) {
-            return node.type === 'BinaryExpression' && node.operator === operator &&
-                ((isUndefinedString(node.right) && getTypeofArgument(node.left)) ||
-                (isUndefinedString(node.left) && getTypeofArgument(node.right)))
-        }
-
-        function checkExpression(nil, operator, node) {
-            return _(nilChecks[nil].expressionChecks)
-                .map(check => check(node, operator))
-                .find()
-        }
-
-        function checkNegatedExpression(nil, node) {
-            return (isNegationExpression(node) && checkExpression(nil, '===', node.argument)) || checkExpression(nil, '!==', node)
-        }
-
-        function isEquivalentExistingExpression(node, leftNil, rightNil) {
-            const leftExp = checkExpression(leftNil, '===', node.left)
-            return leftExp && isEquivalentMemberExp(leftExp, checkExpression(rightNil, '===', node.right))
-        }
-
-        function isEquivalentExistingNegation(node, leftNil, rightNil) {
-            const leftExp = checkNegatedExpression(leftNil, node.left)
-            return leftExp && isEquivalentMemberExp(leftExp, checkNegatedExpression(rightNil, node.right))
-        }
-
-        const visitors = lodashContext.getImportVisitors()
-        visitors.LogicalExpression = function (node) {
-            if (node.operator === '||') {
-                if (isEquivalentExistingExpression(node, 'undefined', 'null') ||
-                    isEquivalentExistingExpression(node, 'null', 'undefined')) {
-                    context.report({node, message: 'Prefer isNil over checking for undefined or null.'})
-                }
-            } else if (isEquivalentExistingNegation(node, 'undefined', 'null') ||
-                isEquivalentExistingNegation(node, 'null', 'undefined')) {
-                context.report({node, message: 'Prefer isNil over checking for undefined or null.'})
-            }
-        }
-        return visitors
-    }
-}

package/src/rules/prefer-map.js

@@ -1,62 +0,0 @@
-/**
- * @fileoverview Rule to check if a call to R.forEach should be a call to R.map
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    schema: [],
-    docs: {
-      url: getDocsUrl("prefer-map"),
-    },
-  },
-
-  create(context) {
-    const { getRemedaMethodVisitors } = require("../util/lodashUtil");
-    const {
-      getFirstFunctionLine,
-      hasOnlyOneStatement,
-      getMethodName,
-      isFunctionDefinitionWithBlock,
-      collectParameterValues,
-    } = require("../util/astUtil");
-    const { isAliasOfMethod } = require("../util/methodDataUtil");
-    const get = require("lodash/get");
-    const includes = require("lodash/includes");
-
-    function onlyHasPush(func) {
-      const firstLine = getFirstFunctionLine(func);
-      const firstParam = get(func, "params[0]");
-      const exp =
-        func && !isFunctionDefinitionWithBlock(func)
-          ? firstLine
-          : firstLine && firstLine.expression;
-      return (
-        func &&
-        hasOnlyOneStatement(func) &&
-        getMethodName(exp) === "push" &&
-        !includes(
-          collectParameterValues(firstParam),
-          get(exp, "callee.object.name"),
-        )
-      );
-    }
-
-    return getRemedaMethodVisitors(context, (node, iteratee, { method }) => {
-      if (isAliasOfMethod("forEach", method) && onlyHasPush(iteratee)) {
-        context.report({
-          node,
-          message:
-            "Prefer R.map over a R.forEach with a push to an array inside",
-        });
-      }
-    });
-  },
-};

package/src/rules/prefer-nullish-coalescing.js

@@ -1,63 +0,0 @@
-/**
- * @fileoverview Rule to prefer nullish coalescing over checking a ternary with !isNullish.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    schema: [],
-    docs: {
-      url: getDocsUrl("prefer-nullish-coalescing"),
-    },
-    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.ConditionalExpression = function (node) {
-      const statement = node.test;
-      if (statement.operator === "!") {
-        if (
-          statement.argument &&
-          statement.argument.callee &&
-          statement.argument.callee.name &&
-          statement.argument.callee.name === "isNullish"
-        ) {
-          const argument = getTextOfNode(statement.argument.arguments[0]);
-          const consequent = getTextOfNode(node.consequent);
-          const alternate = getTextOfNode(node.alternate);
-          if (argument === consequent) {
-            context.report({
-              node,
-              message:
-                "Prefer nullish coalescing over checking a ternary with !isNullish.",
-              fix(fixer) {
-                return fixer.replaceText(node, `${argument} ?? ${alternate}`);
-              },
-            });
-          }
-        }
-      }
-    };
-    return visitors;
-  },
-};

package/src/rules/prefer-remeda-typecheck.js

@@ -1,93 +0,0 @@
-/**
- * @fileoverview Rule to check if there's a method in the chain start that can be in the chain
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    schema: [],
-    docs: {
-      url: getDocsUrl("prefer-remeda-typecheck"),
-    },
-  },
-
-  create(context) {
-    const some = require("lodash/some");
-    const { getIsTypeMethod } = require("../util/lodashUtil");
-
-    const otherSides = {
-      left: "right",
-      right: "left",
-    };
-
-    function isTypeOf(node) {
-      return (
-        node && node.type === "UnaryExpression" && node.operator === "typeof"
-      );
-    }
-
-    function isStrictComparison(node) {
-      return node.operator === "===" || node.operator === "!==";
-    }
-
-    function isDeclaredVariable(node) {
-      const definedVariables = context.getScope().variables;
-      return some(definedVariables, { name: node.name });
-    }
-
-    function getValueForSide(node, side) {
-      const otherSide = otherSides[side];
-      if (
-        isTypeOf(node[side]) &&
-        (node[otherSide].value !== "undefined" ||
-          node[side].argument.type !== "Identifier" ||
-          isDeclaredVariable(node[side].argument))
-      ) {
-        return node[otherSide].value;
-      }
-    }
-
-    function getTypeofCompareType(node) {
-      if (isStrictComparison(node)) {
-        return getValueForSide(node, "left") || getValueForSide(node, "right");
-      }
-    }
-
-    const REPORT_MESSAGE = "Prefer 'R.{{method}}' over {{actual}}.";
-
-    return {
-      BinaryExpression(node) {
-        const typeofCompareType = getTypeofCompareType(node);
-        if (typeofCompareType) {
-          context.report({
-            node,
-            message: REPORT_MESSAGE,
-            data: {
-              method: getIsTypeMethod(typeofCompareType),
-              actual: "'typeof' comparison",
-            },
-          });
-        } else if (node.operator === "instanceof") {
-          const lodashEquivalent = getIsTypeMethod(node.right.name);
-          if (node.right.type === "Identifier" && lodashEquivalent) {
-            context.report({
-              node,
-              message: REPORT_MESSAGE,
-              data: {
-                method: lodashEquivalent,
-                actual: `'instanceof ${node.right.name}'`,
-              },
-            });
-          }
-        }
-      },
-    };
-  },
-};

package/src/rules/prefer-some.js

@@ -1,43 +0,0 @@
-/**
- * @fileoverview Rule to check if a findIndex comparison should be a call to R.some
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      url: getDocsUrl("prefer-some"),
-    },
-    schema: [],
-  },
-
-  create(context) {
-    const { getExpressionComparedToInt } = require("../util/astUtil");
-    const { getRemedaMethodVisitors } = require("../util/lodashUtil");
-    const { isAliasOfMethod } = require("../util/methodDataUtil");
-
-    const visitors = getRemedaMethodVisitors(
-      context,
-      (node, iteratee, { method }) => {
-        if (
-          isAliasOfMethod("findIndex", method) &&
-          node === getExpressionComparedToInt(node.parent, -1, true)
-        ) {
-          context.report({
-            node,
-            message: "Prefer R.some over findIndex comparison to -1",
-          });
-        }
-      },
-    );
-
-    return visitors;
-  },
-};

package/src/rules/prefer-times.js

@@ -1,37 +0,0 @@
-/**
- * @fileoverview Rule to check if a call to map should be a call to times
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    schema: [],
-    docs: {
-      url: getDocsUrl("prefer-times"),
-    },
-  },
-
-  create(context) {
-    const { getRemedaMethodVisitors } = require("../util/lodashUtil");
-    const { isAliasOfMethod } = require("../util/methodDataUtil");
-    const get = require("lodash/get");
-    return getRemedaMethodVisitors(context, (node, iteratee, { method }) => {
-      if (
-        isAliasOfMethod("map", method) &&
-        get(iteratee, "params.length") === 0
-      ) {
-        context.report({
-          node,
-          message: "Prefer R.times over R.map without using arguments",
-        });
-      }
-    });
-  },
-};

package/src/util/LodashContext.js

@@ -1,128 +0,0 @@
-"use strict";
-
-const { getSettings } = require("./settingsUtil");
-const {
-  isMethodCall,
-  isCallFromObject,
-  getCaller,
-  getMethodName,
-} = require("./astUtil");
-const {
-  getNameFromCjsRequire,
-  isFullRemedaImport,
-  getMethodImportFromName,
-} = require("./importUtil");
-
-/* Class representing remeda data for a given context */
-module.exports = class {
-  /**
-   * Create a Remeda context wrapper from a file's RuleContext
-   * @param {RuleContext} context
-   */
-  constructor(context) {
-    this.context = context;
-    this.general = Object.create(null);
-    this.methods = Object.create(null);
-  }
-
-  /**
-   * Gets visitors to collect remeda declarations in the context
-   * @returns {Object} visitors for everywhere Remeda can be declared
-   */
-  getImportVisitors() {
-    const self = this;
-    return {
-      ImportDeclaration({ source, specifiers }) {
-        if (isFullRemedaImport(source.value)) {
-          specifiers.forEach((spec) => {
-            switch (spec.type) {
-              case "ImportNamespaceSpecifier":
-              case "ImportDefaultSpecifier":
-                self.general[spec.local.name] = true;
-                break;
-              case "ImportSpecifier":
-                self.methods[spec.local.name] = spec.imported.name;
-
-                if (spec.imported.name === "chain") {
-                  self.general[spec.local.name] = true;
-                }
-                break;
-            }
-          });
-        } else {
-          const method = getMethodImportFromName(source.value);
-          if (method) {
-            self.methods[specifiers[0].local.name] = method;
-          }
-        }
-      },
-      VariableDeclarator({ init, id }) {
-        const required = getNameFromCjsRequire(init);
-        if (isFullRemedaImport(required)) {
-          if (id.type === "Identifier") {
-            self.general[id.name] = true;
-          } else if (id.type === "ObjectPattern") {
-            id.properties.forEach((prop) => {
-              self.methods[prop.value.name] = prop.key.name;
-
-              if (prop.value.name === "chain") {
-                self.general[prop.value.name] = true;
-              }
-            });
-          }
-        } else if (required) {
-          const method = getMethodImportFromName(required);
-          if (method) {
-            self.methods[id.name] = method;
-          }
-        }
-      },
-    };
-  }
-
-  /**
-   * Returns whether the node is an imported Remeda in this context
-   * @param node
-   * @returns {boolean|undefined}
-   */
-  isImportedRemeda(node) {
-    if (node && node.type === "Identifier") {
-      return this.general[node.name];
-    }
-  }
-
-  /**
-   * Returns the name of the Remeda method for this node, if any
-   * @param node
-   * @returns {string|undefined}
-   */
-  getImportedRemedaMethod(node) {
-    if (node && node.type === "CallExpression" && !isMethodCall(node)) {
-      return this.methods[node.callee.name];
-    }
-  }
-
-  /**
-   * Returns whether the node is a call from a Lodash object
-   * @param node
-   * @returns {boolean|undefined}
-   */
-  isLodashCall(node) {
-    return (
-      (this.pragma && isCallFromObject(node, this.pragma)) ||
-      this.isImportedRemeda(getCaller(node))
-    );
-  }
-
-  /**
-   *
-   * @returns {string|undefined} the current Remeda pragma
-   */
-  get pragma() {
-    if (!this._pragma) {
-      const { pragma } = getSettings(this.context);
-      this._pragma = pragma;
-    }
-    return this._pragma;
-  }
-};