eslint-plugin-remeda 1.0.0

package/src/util/astUtil.js

@@ -0,0 +1,353 @@
+'use strict'
+const _ = require('lodash')
+
+/**
+ * Gets the object that called the method in a CallExpression
+ * @param {Object} node
+ * @returns {Object|undefined}
+ */
+const getCaller = _.property(['callee', 'object'])
+
+/**
+ * Gets the name of a method in a CallExpression
+ * @param {Object} node
+ * @returns {string|undefined}
+ */
+const getMethodName = _.property(['callee', 'property', 'name'])
+
+/**
+ * Returns whether the node is a method call
+ * @param {Object} node
+ * @returns {boolean}
+ */
+const isMethodCall = _.matches({type: 'CallExpression', callee: {type: 'MemberExpression'}})
+
+const isFunctionExpression = _.overSome(
+    _.matchesProperty('type', 'FunctionExpression'),
+    _.matchesProperty('type', 'FunctionDeclaration')
+)
+/**
+ * Returns whether the node is a function declaration that has a block
+ * @param {Object} node
+ * @returns {boolean}
+ */
+const isFunctionDefinitionWithBlock = _.overSome(
+    isFunctionExpression,
+    _.matches({type: 'ArrowFunctionExpression', body: {type: 'BlockStatement'}})
+)
+
+/**
+ * If the node specified is a function, returns the node corresponding with the first statement/expression in that function
+ * @param {Object} node
+ * @returns {node|undefined}
+ */
+const getFirstFunctionLine = _.cond([
+    [isFunctionDefinitionWithBlock, _.property(['body', 'body', 0])],
+    [_.matches({type: 'ArrowFunctionExpression'}), _.property('body')]
+])
+
+/**
+ *
+ * @param {Object} node
+ * @returns {boolean|undefined}
+ */
+const isPropAccess = _.overSome(_.matches({computed: false}), _.matchesProperty(['property', 'type'], 'Literal'))
+
+/**
+ * Returns whether the node is a member expression starting with the same object, up to the specified length
+ * @param {Object} node
+ * @param {string} objectName
+ * @param {Object} [options]
+ * @param {number} [options.maxLength]
+ * @param {boolean} [options.allowComputed]
+ * @returns {boolean|undefined}
+ */
+function isMemberExpOf(node, objectName, {maxLength = Number.MAX_VALUE, allowComputed} = {}) {
+    if (objectName) {
+        let curr = node
+        let depth = maxLength
+        while (curr && depth) {
+            if (allowComputed || isPropAccess(curr)) {
+                if (curr.type === 'MemberExpression' && curr.object.name === objectName) {
+                    return true
+                }
+                curr = curr.object
+                depth--
+            } else {
+                return false
+            }
+        }
+    }
+}
+
+/**
+ * Returns the name of the first parameter of a function, if it exists
+ * @param {Object} func
+ * @returns {string|undefined}
+ */
+const getFirstParamName = _.property(['params', 0, 'name'])
+
+/**
+ * Returns whether or not the expression is a return statement
+ * @param {Object} exp
+ * @returns {boolean|undefined}
+ */
+const isReturnStatement = _.matchesProperty('type', 'ReturnStatement')
+
+/**
+ * Returns whether the node specified has only one statement
+ * @param {Object} func
+ * @returns {boolean}
+ */
+function hasOnlyOneStatement(func) {
+    if (isFunctionDefinitionWithBlock(func)) {
+        return _.get(func, 'body.body.length') === 1
+    }
+    if (func.type === 'ArrowFunctionExpression') {
+        return !_.get(func, 'body.body')
+    }
+}
+
+/**
+ * Returns whether the node is an object of a method call
+ * @param {Object} node
+ * @returns {boolean}
+ */
+function isObjectOfMethodCall(node) {
+    return _.get(node, 'parent.object') === node && _.get(node, 'parent.parent.type') === 'CallExpression'
+}
+
+/**
+ * Returns whether the node is a literal
+ * @param {Object} node
+ * @returns {boolean}
+ */
+function isLiteral(node) {
+    return node.type === 'Literal'
+}
+
+/**
+ * Returns whether the expression specified is a binary expression with the specified operator and one of its sides is a member expression of the specified object name
+ * @param {string} operator
+ * @param {Object} exp
+ * @param {string} objectName
+ * @param {number} maxLength
+ * @param {boolean} allowComputed
+ * @param {boolean} onlyLiterals
+ * @returns {boolean|undefined}
+ */
+function isBinaryExpWithMemberOf(operator, exp, objectName, {maxLength, allowComputed, onlyLiterals} = {}) {
+    if (!_.isMatch(exp, {type: 'BinaryExpression', operator})) {
+        return false
+    }
+    const [left, right] = [exp.left, exp.right].map(side => isMemberExpOf(side, objectName, {maxLength, allowComputed}))
+    return (left === !right) && (!onlyLiterals || isLiteral(exp.left) || isLiteral(exp.right))
+}
+
+
+/**
+ * Returns whether the specified expression is a negation.
+ * @param {Object} exp
+ * @returns {boolean|undefined}
+ */
+const isNegationExpression = _.matches({type: 'UnaryExpression', operator: '!'})
+
+/**
+ * Returns whether the expression is a negation of a member of objectName, in the specified depth.
+ * @param {Object} exp
+ * @param {string} objectName
+ * @param {number} maxLength
+ * @returns {boolean|undefined}
+ */
+function isNegationOfMemberOf(exp, objectName, {maxLength} = {}) {
+    return isNegationExpression(exp) && isMemberExpOf(exp.argument, objectName, {maxLength, allowComputed: false})
+}
+
+/**
+ *
+ * @param {Object} exp
+ * @param {string} paramName
+ * @returns {boolean|undefined}
+ */
+function isIdentifierWithName(exp, paramName) {
+    return exp && paramName && exp.type === 'Identifier' && exp.name === paramName
+}
+
+/**
+ * Returns the node of the value returned in the first line, if any
+ * @param {Object} func
+ * @returns {Object|undefined}
+ */
+function getValueReturnedInFirstStatement(func) {
+    const firstLine = getFirstFunctionLine(func)
+    if (func) {
+        if (isFunctionDefinitionWithBlock(func)) {
+            return isReturnStatement(firstLine) ? firstLine.argument : undefined
+        }
+        if (func.type === 'ArrowFunctionExpression') {
+            return firstLine
+        }
+    }
+}
+
+/**
+ * Returns whether the node is a call from the specified object name
+ * @param {Object} node
+ * @param {string} objName
+ * @returns {boolean|undefined}
+ */
+function isCallFromObject(node, objName) {
+    return node && objName && node.type === 'CallExpression' && _.get(node, 'callee.object.name') === objName
+}
+
+/**
+ * Returns whether the node is actually computed (x['ab'] does not count, x['a' + 'b'] does
+ * @param {Object} node
+ * @returns {boolean|undefined}
+ */
+function isComputed(node) {
+    return _.get(node, 'computed') && node.property.type !== 'Literal'
+}
+
+/**
+ * Returns whether the two expressions refer to the same object (e.g. a['b'].c and a.b.c)
+ * @param {Object} a
+ * @param {Object} b
+ * @returns {boolean}
+ */
+function isEquivalentMemberExp(a, b) {
+    return _.isEqualWith(a, b, (left, right, key) => {
+        if (_.includes(['loc', 'range', 'computed', 'start', 'end', 'parent'], key)) {
+            return true
+        }
+        if (isComputed(left) || isComputed(right)) {
+            return false
+        }
+        if (key === 'property') {
+            const leftValue = left.name || left.value
+            const rightValue = right.name || right.value
+            return leftValue === rightValue
+        }
+    })
+}
+
+/**
+ * Returns whether the expression is a strict equality comparison, ===
+ * @param {Object} node
+ * @returns {boolean}
+ */
+const isEqEqEq = _.matches({type: 'BinaryExpression', operator: '==='})
+
+
+const isMinus = node => node.type === 'UnaryExpression' && node.operator === '-'
+
+/**
+ * Enum for type of comparison to int literal
+ * @readonly
+ * @enum {number}
+ */
+const comparisonType = {
+    exact: 0,
+    over: 1,
+    under: 2,
+    any: 3
+}
+const comparisonOperators = ['==', '!=', '===', '!==']
+
+function getIsValue(value) {
+    return value < 0 ? _.overEvery(isMinus, _.matches({argument: {value: -value}})) : _.matches({value})
+}
+
+/**
+ * Returns the expression compared to the value in a binary expression, or undefined if there isn't one
+ * @param {Object} node
+ * @param {number} value
+ * @param {boolean} [checkOver=false]
+ * @returns {Object|undefined}
+ */
+function getExpressionComparedToInt(node, value, checkOver) {
+    const isValue = getIsValue(value)
+    if (_.includes(comparisonOperators, node.operator)) {
+        if (isValue(node.right)) {
+            return node.left
+        }
+        if (isValue(node.left)) {
+            return node.right
+        }
+    }
+    if (checkOver) {
+        if (node.operator === '>' && isValue(node.right)) {
+            return node.left
+        }
+        if (node.operator === '<' && isValue(node.left)) {
+            return node.right
+        }
+        const isNext = getIsValue(value + 1)
+        if ((node.operator === '>=' || node.operator === '<') && isNext(node.right)) {
+            return node.left
+        }
+        if ((node.operator === '<=' || node.operator === '>') && isNext(node.left)) {
+            return node.right
+        }
+    }
+}
+
+/**
+ * Returns whether the node is a call to indexOf
+ * @param {Object} node
+ * @returns {boolean}
+ */
+const isIndexOfCall = node => isMethodCall(node) && getMethodName(node) === 'indexOf'
+
+/**
+ * Returns whether the node is a call to findIndex
+ * @param {Object} node
+ * @returns {boolean}
+ */
+const isFindIndexCall = node => isMethodCall(node) && getMethodName(node) === 'findIndex'
+
+/**
+ * Returns an array of identifier names returned in a parameter or variable definition
+ * @param node an AST node which is a parameter or variable declaration
+ * @returns {string[]} List of names defined in the parameter
+ */
+function collectParameterValues(node) {
+    switch (node && node.type) {
+        case 'Identifier':
+            return [node.name]
+        case 'ObjectPattern':
+            return _.flatMap(node.properties, prop => collectParameterValues(prop.value))
+        case 'ArrayPattern':
+            return _.flatMap(node.elements, collectParameterValues)
+        default:
+            return []
+    }
+}
+
+module.exports = {
+    getCaller,
+    getMethodName,
+    isMethodCall,
+    getFirstFunctionLine,
+    isMemberExpOf,
+    getFirstParamName,
+    hasOnlyOneStatement,
+    isObjectOfMethodCall,
+    isEqEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, '==='),
+    isNotEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, '!=='),
+    isNegationOfMemberOf,
+    isIdentifierWithName,
+    isNegationExpression,
+    getValueReturnedInFirstStatement,
+    isCallFromObject,
+    isComputed,
+    isEquivalentMemberExp,
+    isEqEqEq,
+    comparisonType,
+    getExpressionComparedToInt,
+    isIndexOfCall,
+    isFindIndexCall,
+    isFunctionExpression,
+    isFunctionDefinitionWithBlock,
+    collectParameterValues
+}

package/src/util/getDocsUrl.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const pkg = require("../../package.json");
+
+const REPO_URL = "https://github.com/wix/eslint-plugin-lodash";
+
+/**
+ * Generates the URL to documentation for the given rule name. It uses the
+ * package version to build the link to a tagged version of the
+ * documentation file.
+ *
+ * @param {string} ruleName - Name of the eslint rule
+ * @returns {string} URL to the documentation for the given rule
+ */
+module.exports = function getDocsUrl(ruleName) {
+  return `${REPO_URL}/blob/v${pkg.version}/docs/rules/${ruleName}.md`;
+};

package/src/util/importUtil.js

@@ -0,0 +1,24 @@
+"use strict";
+const get = require("lodash/get");
+
+function getNameFromCjsRequire(init) {
+  if (
+    get(init, "callee.name") === "require" &&
+    get(init, "arguments.length") === 1 &&
+    init.arguments[0].type === "Literal"
+  ) {
+    return init.arguments[0].value;
+  }
+}
+
+const isFullRemedaImport = (str) => /^remeda?(\/)?$/.test(str);
+const getMethodImportFromName = (str) => {
+  const match = /^remeda([./])(\w+)$/.exec(str);
+  return match && match[2];
+};
+
+module.exports = {
+  getNameFromCjsRequire,
+  isFullRemedaImport,
+  getMethodImportFromName,
+};

package/src/util/lodashUtil.js

@@ -0,0 +1,123 @@
+"use strict";
+const _ = require("lodash");
+const methodDataUtil = require("./methodDataUtil");
+const astUtil = require("./astUtil");
+const LodashContext = require("./LodashContext");
+
+/**
+ * Returns whether the node is a chain breaker method
+ * @param {Object} node
+ * @returns {boolean}
+ */
+function isChainBreaker(node) {
+  return methodDataUtil.isAliasOfMethod("value", astUtil.getMethodName(node));
+}
+
+/**
+ * Returns whether the node is a call to the specified method or one of its aliases.
+ * @param {Object} node
+ * @param {string} method
+ * @returns {boolean}
+ */
+function isCallToMethod(node, method) {
+  return methodDataUtil.isAliasOfMethod(method, astUtil.getMethodName(node));
+}
+
+/**
+ * Gets the 'isX' method for a specified type, e.g. isObject
+ * @param {string} name
+ * @returns {string|null}
+ */
+function getIsTypeMethod(name) {
+  const types = [
+    "number",
+    "boolean",
+    "function",
+    "Function",
+    "string",
+    // "object",
+    // "undefined",
+    "Date",
+    "Array",
+    "Error",
+    // "Element",
+  ];
+  return _.includes(types, name) ? `is${_.capitalize(name)}` : null;
+}
+
+/**
+ * Gets the context's Lodash settings and a function and returns a visitor that calls the function for every Lodash or chain call
+ * @param {LodashContext} lodashContext
+ * @param {LodashReporter} reporter
+ * @returns {NodeTypeVisitor}
+ */
+function getRemedaMethodCallExpVisitor(lodashContext, reporter) {
+  return function (node) {
+    let iterateeIndex;
+    if (lodashContext.isLodashCall(node)) {
+      const method = astUtil.getMethodName(node);
+      iterateeIndex = methodDataUtil.getIterateeIndex(method);
+      reporter(node, node.arguments[iterateeIndex], {
+        callType: "method",
+        method,
+        lodashContext,
+      });
+    } else {
+      const method = lodashContext.getImportedRemedaMethod(node);
+      if (method) {
+        iterateeIndex = methodDataUtil.getIterateeIndex(method);
+        reporter(node, node.arguments[iterateeIndex], {
+          method,
+          callType: "single",
+          lodashContext,
+        });
+      }
+    }
+  };
+}
+
+function isRemedaCallToMethod(node, method, lodashContext) {
+  return lodashContext.isLodashCall(node) && isCallToMethod(node, method);
+}
+
+function isCallToRemedaMethod(node, method, lodashContext) {
+  if (!node || node.type !== "CallExpression") {
+    return false;
+  }
+  return (
+    isRemedaCallToMethod(node, method, lodashContext) ||
+    methodDataUtil.isAliasOfMethod(
+      method,
+      lodashContext.getImportedRemedaMethod(node),
+    )
+  );
+}
+
+function getRemedaMethodVisitors(context, lodashCallExpVisitor) {
+  const lodashContext = new LodashContext(context);
+  const visitors = lodashContext.getImportVisitors();
+  visitors.CallExpression = getRemedaMethodCallExpVisitor(
+    lodashContext,
+    lodashCallExpVisitor,
+  );
+  return visitors;
+}
+
+/**
+ *
+ * @param context
+ * @returns {LodashContext} a LodashContext for a given context
+ */
+function getLodashContext(context) {
+  return new LodashContext(context);
+}
+
+module.exports = {
+  isChainBreaker,
+  isCallToMethod,
+  getIsTypeMethod,
+  getRemedaMethodCallExpVisitor,
+  isCallToLodashMethod: isCallToRemedaMethod,
+  getRemedaMethodVisitors,
+  getLodashContext,
+};