add support for settings object with pragma (fixes #1)

lib/rules/chain-style.js

@@ -9,10 +9,11 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
 
     var callExpressionVisitors = {
         'as-needed': function (node) {
-            if (lodashUtil.isExplicitChainStart(node)) {
+            if (lodashUtil.isExplicitChainStart(node, lodashPragma)) {
                 var curr = node.parent.parent;
                 var needed = false;
                 while (astUtil.isMethodCall(curr) && !lodashUtil.isChainBreaker(curr)) {
@@ -27,12 +28,12 @@ module.exports = function (context) {
             }
         },
         implicit: function (node) {
-            if (lodashUtil.isExplicitChainStart(node)) {
+            if (lodashUtil.isExplicitChainStart(node, lodashPragma)) {
                 context.report(node, 'Do not use explicit chaining');
             }
         },
         explicit: function (node) {
-            if (lodashUtil.isImplicitChainStart(node)) {
+            if (lodashUtil.isImplicitChainStart(node, lodashPragma)) {
                 context.report(node, 'Do not use implicit chaining');
             }
         }

lib/rules/collection-return.js

@@ -11,6 +11,8 @@ module.exports = function (context) {
     var _ = require('lodash');
     var astUtil = require('../util/astUtil');
     var lodashUtil = require('../util/lodashUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
+
     var callStack = [];
 
     function handleExitOfFunctionWithBlock(node) {
@@ -24,7 +26,7 @@ module.exports = function (context) {
         }
     }
     function addToCallStackIfCollectionMethod(node) {
-        if (node.parent.type === 'CallExpression' && lodashUtil.isLodashCollectionMethod(node.parent)) {
+        if (node.parent.type === 'CallExpression' && lodashUtil.isLodashCollectionMethod(node.parent, lodashPragma)) {
             callStack.push({node: node.parent});
         }
     }

lib/rules/matches-prop-shorthand.js

@@ -9,6 +9,7 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
 
     var SUPPORT_MATCHES_PROPERTY_STYLE_CB = ['find', 'detect', 'filter', 'select', 'reject', 'findIndex', 'findLastIndex', 'some', 'every'];
 
@@ -38,7 +39,7 @@ module.exports = function (context) {
     };
 
     return {
-        CallExpression: lodashUtil.getLodashMethodVisitor(callExpressionReporters[context.options[0] || 'always'])
+        CallExpression: lodashUtil.getLodashMethodVisitor(lodashPragma, callExpressionReporters[context.options[0] || 'always'])
     };
 };
 

lib/rules/matches-shorthand.js

@@ -10,6 +10,7 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
 
     var SUPPORT_MATCHES_STYLE_CB = ['find', 'detect', 'filter', 'select', 'reject', 'findIndex', 'findLastIndex', 'some', 'every'];
     var DEFAULT_MAX_PROPERTY_PATH_LENGTH = 3;
@@ -60,7 +61,7 @@ module.exports = function (context) {
     };
 
     return {
-        CallExpression: lodashUtil.getLodashMethodVisitor(callExpressionReporters[context.options[0] || 'always'])
+        CallExpression: lodashUtil.getLodashMethodVisitor(lodashPragma, callExpressionReporters[context.options[0] || 'always'])
     };
 };
 

lib/rules/no-commit.js

@@ -10,11 +10,12 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
 
 
     return {
         CallExpression: function (node) {
-            if (lodashUtil.isLodashChainStart(node)) {
+            if (lodashUtil.isLodashChainStart(node, lodashPragma)) {
                 do {
                     node = node.parent.parent;
                 } while (astUtil.isMethodCall(node) && !lodashUtil.isCallToMethod(node, 'commit'));

lib/rules/no-double-unwrap.js

@@ -10,9 +10,10 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
     return {
         CallExpression: function (node) {
-            if (lodashUtil.isImplicitChainStart(node)) {
+            if (lodashUtil.isImplicitChainStart(node, lodashPragma)) {
                 do {
                     node = node.parent.parent;
                 } while (astUtil.isMethodCall(node) && !lodashUtil.isChainBreaker(node));

lib/rules/no-single-chain.js

@@ -10,6 +10,7 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
 
     function isEndOfChain(node) {
         return !astUtil.isObjectOfMethodCall(node);
@@ -21,7 +22,7 @@ module.exports = function (context) {
 
     return {
         CallExpression: function (node) {
-            if (lodashUtil.isLodashChainStart(node)) {
+            if (lodashUtil.isLodashChainStart(node, lodashPragma)) {
                 var firstCall = node.parent.parent;
                 if (astUtil.isMethodCall(firstCall) && (isEndOfChain(firstCall) || isBeforeChainBreaker(firstCall))) {
                     context.report(firstCall, 'Do not use chain syntax for single method');

lib/rules/no-unnecessary-bind.js

@@ -10,13 +10,14 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
 
     function isBound(node) {
         return node && node.type === 'CallExpression' && astUtil.getMethodName(node) === 'bind' && node.arguments.length === 1;
     }
 
     return {
-        CallExpression: lodashUtil.getLodashMethodVisitor(function (node, iteratee) {
+        CallExpression: lodashUtil.getLodashMethodVisitor(lodashPragma, function (node, iteratee) {
             if (isBound(iteratee)) {
                 context.report(iteratee.callee.property, 'Unnecessary bind, pass `thisArg` to lodash method instead');
             }

lib/rules/prefer-chain.js

@@ -11,10 +11,12 @@ module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
     var DEFAULT_LENGTH = 3;
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
+
     var ruleDepth = parseInt(context.options[0], 10) || DEFAULT_LENGTH;
 
     function isNestedNLevels(node, n) {
-        return n === 0 || lodashUtil.isLodashCall(node) && isNestedNLevels(node.arguments[0], n - 1);
+        return n === 0 || lodashUtil.isLodashCall(node, lodashPragma) && isNestedNLevels(node.arguments[0], n - 1);
     }
 
     return {

lib/rules/prefer-compact.js

@@ -10,6 +10,8 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
+
 
     function isDoubleNegationOfParam(exp, paramName) {
         return astUtil.isNegationExpression(exp) && astUtil.isNegationExpression(exp.argument) && astUtil.isIdentifierOfParam(exp.argument.argument, paramName);
@@ -28,7 +30,7 @@ module.exports = function (context) {
     }
 
     return {
-        CallExpression: lodashUtil.getLodashMethodVisitor(function (node, iteratee) {
+        CallExpression: lodashUtil.getLodashMethodVisitor(lodashPragma, function (node, iteratee) {
             if (lodashUtil.isCallToMethod(node, 'filter') && isBooleanCastingFunction(iteratee)) {
                 context.report(node, 'Prefer _.compact over filtering of Boolean casting');
             }

lib/rules/prefer-filter.js

@@ -10,6 +10,7 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
 
     var DEFAULT_MAX_PROPERTY_PATH_LENGTH = 3;
     var maxPropertyPathLength = parseInt(context.options[0], 10) || DEFAULT_MAX_PROPERTY_PATH_LENGTH;
@@ -30,7 +31,7 @@ module.exports = function (context) {
     }
 
     return {
-        CallExpression: lodashUtil.getLodashMethodVisitor(function (node, iteratee) {
+        CallExpression: lodashUtil.getLodashMethodVisitor(lodashPragma, function (node, iteratee) {
             if (lodashUtil.isCallToMethod(node, 'forEach') && onlyHasSimplifiableIf(iteratee)) {
                 context.report(node, 'Prefer _.filter or _.some over an if statement inside a _.forEach');
             }

lib/rules/prefer-invoke.js

@@ -10,13 +10,15 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
+
 
     function isFunctionMethodCallOfParam(func) {
         return astUtil.isCallFromObject(astUtil.getValueReturnedInFirstLine(func), astUtil.getFirstParamName(func));
     }
 
     return {
-        CallExpression: lodashUtil.getLodashMethodVisitor(function (node, iteratee) {
+        CallExpression: lodashUtil.getLodashMethodVisitor(lodashPragma, function (node, iteratee) {
             if (lodashUtil.isCallToMethod(node, 'map') && isFunctionMethodCallOfParam(iteratee)) {
                 context.report(node, 'Prefer _.invoke over map to a method call.');
             }

lib/rules/prefer-lodash-chain.js

@@ -10,12 +10,14 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
+
 
     var REPORT_MESSAGE = 'Prefer lodash chain';
 
     return {
         CallExpression: function (node) {
-            if (lodashUtil.isLodashChainStart(node)) {
+            if (lodashUtil.isLodashChainStart(node, lodashPragma)) {
                 do {
                     node = node.parent.parent;
                 } while (astUtil.isMethodCall(node) && !lodashUtil.isChainBreaker(node));
@@ -25,7 +27,7 @@ module.exports = function (context) {
                         context.report(callAfterChainBreak, REPORT_MESSAGE);
                     }
                 }
-            } else if (lodashUtil.isLodashCall(node)) {
+            } else if (lodashUtil.isLodashCall(node, lodashPragma)) {
                 if (astUtil.isMethodCall(node.parent.parent) && (lodashUtil.isNativeCollectionMethodCall(node.parent.parent))) {
                     context.report(node.parent.parent, REPORT_MESSAGE);
                 }

lib/rules/prefer-lodash-method.js

@@ -11,6 +11,7 @@ module.exports = function (context) {
     var _ = require('lodash');
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
 
     var REPORT_MESSAGE = 'Prefer \'_.{{method}}\' over the native function.';
 
@@ -25,7 +26,7 @@ module.exports = function (context) {
 
     return {
         CallExpression: function (node) {
-            if (!(lodashUtil.isLodashCall(node) || lodashUtil.isLodashWrapper(astUtil.getCaller(node))) && (lodashUtil.isNativeCollectionMethodCall(node) || isStaticNativeMethodCall(node))) {
+            if (!(lodashUtil.isLodashCall(node, lodashPragma) || lodashUtil.isLodashWrapper(astUtil.getCaller(node), lodashPragma)) && (lodashUtil.isNativeCollectionMethodCall(node) || isStaticNativeMethodCall(node))) {
                 context.report(node, REPORT_MESSAGE, {method: astUtil.getMethodName(node)});
             }
         }

lib/rules/prefer-map.js

@@ -10,6 +10,8 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
+
 
     function onlyHasPush(func) {
         var firstLine = astUtil.getFirstFunctionLine(func);
@@ -18,7 +20,7 @@ module.exports = function (context) {
     }
 
     return {
-        CallExpression: lodashUtil.getLodashMethodVisitor(function (node, iteratee) {
+        CallExpression: lodashUtil.getLodashMethodVisitor(lodashPragma, function (node, iteratee) {
             if (lodashUtil.isCallToMethod(node, 'forEach') && onlyHasPush(iteratee)) {
                 context.report(node, 'Prefer _.map over a _.forEach with a push to an array inside');
             }

lib/rules/prefer-reject.js

@@ -10,6 +10,8 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
+
 
     var DEFAULT_MAX_PROPERTY_PATH_LENGTH = 3;
     var maxPropertyPathLength = parseInt(context.options[0], 10) || DEFAULT_MAX_PROPERTY_PATH_LENGTH;
@@ -22,7 +24,7 @@ module.exports = function (context) {
     }
 
     return {
-        CallExpression: lodashUtil.getLodashMethodVisitor(function (node, iteratee) {
+        CallExpression: lodashUtil.getLodashMethodVisitor(lodashPragma, function (node, iteratee) {
             if (lodashUtil.isCallToMethod(node, 'filter') && isNegativeExpressionFunction(iteratee)) {
                 context.report(node, 'Prefer _.reject over negative condition');
             }

lib/rules/prefer-thru.js

@@ -9,14 +9,15 @@
 
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
 
     function isSingleArgumentFunctionCall(node) {
         return node && node.type === 'CallExpression' && node.arguments.length === 1 && node.arguments[0].type !== 'Literal';
     }
 
     return {
         CallExpression: function (node) {
-            if (lodashUtil.isLodashChainStart(node) && isSingleArgumentFunctionCall(node.arguments[0])) {
+            if (lodashUtil.isLodashChainStart(node, lodashPragma) && isSingleArgumentFunctionCall(node.arguments[0])) {
                 context.report(node, 'Prefer using thru instead of function call in chain start.');
             }
         }

lib/rules/prefer-times.js

@@ -11,13 +11,14 @@ module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var _ = require('lodash');
     var callStack = [];
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
 
     function getParamName(paramNode) {
         return paramNode.name || paramNode.left.name;
     }
 
     function handleFunctionExpression(node) {
-        if (lodashUtil.isCallToMethod(node.parent, 'map') && (lodashUtil.isLodashCall(node.parent) || lodashUtil.isLodashWrapper(node.parent))) {
+        if (lodashUtil.isCallToMethod(node.parent, 'map') && (lodashUtil.isLodashCall(node.parent, lodashPragma) || lodashUtil.isLodashWrapper(node.parent, lodashPragma))) {
             callStack.push({func: node, params: _.map(node.params, getParamName), anyUsed: false});
         }
     }

lib/rules/prefer-wrapper-method.js

@@ -9,10 +9,12 @@
 
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
+
 
     return {
         CallExpression: function (node) {
-            if (lodashUtil.isLodashChainStart(node) && lodashUtil.isLodashWrapperMethod(node.arguments[0])) {
+            if (lodashUtil.isLodashChainStart(node, lodashPragma) && lodashUtil.isLodashWrapperMethod(node.arguments[0])) {
                 context.report(node, 'Prefer {{name}} with wrapper method over inside the chain start.', {name: node.arguments[0].callee.property.name});
             }
         }

lib/rules/preferred-alias.js

@@ -12,14 +12,16 @@ module.exports = function (context) {
     var aliasMap = require('../util/aliases');
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
+
 
     var aliases = _.reduce(aliasMap.ALIASES, function (result, aliasesForKey, key) {
         var mapToMainKey = _.zipObject(aliasesForKey, _.fill(new Array(aliasesForKey.length), key));
         return _.assign(result, mapToMainKey);
     }, {});
 
     return {
-        CallExpression: lodashUtil.getLodashMethodVisitor(function (node) {
+        CallExpression: lodashUtil.getLodashMethodVisitor(lodashPragma, function (node) {
             var methodName = astUtil.getMethodName(node);
             if (_.has(aliases, methodName)) {
                 context.report(node.callee.property, "Method '{{old}}' is an alias, for consistency prefer using '{{new}}'", {old: methodName, new: aliases[methodName]});

lib/rules/prop-shorthand.js

@@ -13,6 +13,8 @@ module.exports = function (context) {
     var aliasMap = require('../util/aliases');
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
+
 
     function canUseShorthand(func) {
         return astUtil.isMemberExpOf(astUtil.getValueReturnedInFirstLine(func), astUtil.getFirstParamName(func), Number.MAX_VALUE, false);
@@ -40,7 +42,7 @@ module.exports = function (context) {
     };
 
     return {
-        CallExpression: lodashUtil.getLodashMethodVisitor(callExpressionReporters[context.options[0] || 'always'])
+        CallExpression: lodashUtil.getLodashMethodVisitor(lodashPragma, callExpressionReporters[context.options[0] || 'always'])
     };
 };
 

lib/rules/unwrap.js

@@ -9,15 +9,17 @@
 
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
+    var lodashPragma = require('../util/settingsUtil').getLodashPragma(context);
+
     function isExplicitChainWithoutBreaker(node) {
-        return lodashUtil.isExplicitMethodChaining(node) && !lodashUtil.isChainBreaker(node);
+        return lodashUtil.isExplicitMethodChaining(node, lodashPragma) && !lodashUtil.isChainBreaker(node);
     }
     function isEvaluatedWhenLazy(node) {
         return lodashUtil.isCallToMethod(node, 'commit') || !lodashUtil.isChainable(node);
     }
     return {
         CallExpression: function (node) {
-            if (lodashUtil.isEndOfChain(node) && (!isEvaluatedWhenLazy(node) || isExplicitChainWithoutBreaker(node))) {
+            if (lodashUtil.isEndOfChain(node, lodashPragma) && (!isEvaluatedWhenLazy(node) || isExplicitChainWithoutBreaker(node))) {
                 context.report(node, 'Missing unwrapping at end of chain');
             }
         }