add support for arrow functions

lib/rules/matches-prop-shorthand.js

@@ -15,8 +15,7 @@ module.exports = function (context) {
     var SUPPORT_MATCHES = ['find', 'detect', 'filter', 'select', 'reject'];
 
     function shouldPreferMatches(func) {
-        var firstLine = astUtil.getFirstFunctionLine(func);
-        return astUtil.isReturnStatement(firstLine) && astUtil.isEqEqEqToParamMember(firstLine.argument, astUtil.getFirstParamName(func));
+        return astUtil.isEqEqEqToParamMember(astUtil.getValueReturnedInFirstLine(func), astUtil.getFirstParamName(func));
     }
 
     function methodSupportsShorthand(node) {

lib/rules/prefer-compact.js

@@ -16,16 +16,15 @@ module.exports = function (context) {
     }
 
     function isCallToBooleanCastOfParam(exp, paramName) {
-        return exp.type === 'CallExpression' && exp.callee.name === 'Boolean' && astUtil.isIdentifierOfParam(exp.arguments[0], paramName);
+        return exp && exp.type === 'CallExpression' && exp.callee.name === 'Boolean' && astUtil.isIdentifierOfParam(exp.arguments[0], paramName);
     }
 
     function isBooleanCastingFunction(func) {
-        var firstLine = astUtil.getFirstFunctionLine(func);
+        var returnValue = astUtil.getValueReturnedInFirstLine(func);
         var paramName = astUtil.getFirstParamName(func);
         return (func && func.type === 'Identifier' && func.name === 'Boolean') ||
-            (astUtil.isReturnStatement(firstLine) && (astUtil.isIdentifierOfParam(firstLine.argument, paramName) ||
-            isDoubleNegationOfParam(firstLine.argument, paramName) || isCallToBooleanCastOfParam(firstLine.argument, paramName)));
-
+            (astUtil.isIdentifierOfParam(returnValue, paramName) ||
+            isDoubleNegationOfParam(returnValue, paramName) || isCallToBooleanCastOfParam(returnValue, paramName));
     }
 
     return {

lib/rules/prefer-filter.js

@@ -10,6 +10,11 @@
 module.exports = function (context) {
     var lodashUtil = require('../util/lodashUtil');
     var astUtil = require('../util/astUtil');
+    var aliases = require('../util/aliases');
+
+    function isForEach(node) {
+        return aliases.isAliasOfMethod('forEach', astUtil.getMethodName(node));
+    }
 
     function isIfWithoutElse(statement) {
         return statement && statement.type === 'IfStatement' && !statement.alternate;
@@ -27,7 +32,7 @@ module.exports = function (context) {
 
     return {
         CallExpression: function (node) {
-            if (lodashUtil.isCallToMethod(node, 'forEach') && onlyHasSimplifiableIf(lodashUtil.getLodashIteratee(node))) {
+            if (isForEach(node) && onlyHasSimplifiableIf(lodashUtil.getLodashIteratee(node))) {
                 context.report(node, 'Prefer _.filter or _.some over an if statement inside a _.forEach');
             }
         }

lib/rules/prefer-reject.js

@@ -12,19 +12,17 @@ module.exports = function (context) {
     var astUtil = require('../util/astUtil');
 
     function isNegativeExpressionFunction(func) {
-        var firstLine = astUtil.getFirstFunctionLine(func);
+        var returnValue = astUtil.getValueReturnedInFirstLine(func);
         var firstParamName = astUtil.getFirstParamName(func);
-        return astUtil.isReturnStatement(firstLine) &&
-            (astUtil.isNegationOfParamMember(firstLine.argument, firstParamName) ||
-            astUtil.isNotEqEqToParamMember(firstLine.argument, firstParamName));
+        return astUtil.isNegationOfParamMember(returnValue, firstParamName) ||
+            astUtil.isNotEqEqToParamMember(returnValue, firstParamName);
     }
 
     return {
         CallExpression: function (node) {
             if (lodashUtil.isCallToMethod(node, 'filter') && isNegativeExpressionFunction(lodashUtil.getLodashIteratee(node))) {
                 context.report(node, 'Prefer _.reject over negative condition');
             }
-
         }
     };
 };

lib/rules/prop-shorthand.js

@@ -14,8 +14,7 @@ module.exports = function (context) {
     var astUtil = require('../util/astUtil');
 
     function canUseShorthand(func) {
-        var firstLine = astUtil.getFirstFunctionLine(func);
-        return astUtil.isReturnStatement(firstLine) && astUtil.isMemberExpOfArg(firstLine.argument, astUtil.getFirstParamName(func));
+        return astUtil.isMemberExpOfArg(astUtil.getValueReturnedInFirstLine(func), astUtil.getFirstParamName(func));
     }
 
     function methodSupportsShorthand(node) {

lib/util/astUtil.js

@@ -13,8 +13,20 @@ function isMethodCall(node) {
     return node && node.type === 'CallExpression' && node.callee.type === 'MemberExpression';
 }
 
+function isFunctionDefinitionWithBlock(node) {
+    return (node.type === 'FunctionExpression' || (node.type === 'ArrowFunctionExpression' && node.body.type === 'BlockStatement'));
+}
+
 function getFirstFunctionLine(node) {
-    return node && node.type === 'FunctionExpression' && _.get(node, 'body.body[0]');
+    if (node) {
+        if (isFunctionDefinitionWithBlock(node)) {
+            return _.get(node, 'body.body[0]');
+        }
+        if (node.type === 'ArrowFunctionExpression') {
+            return node.body;
+        }
+    }
+    return null;
 }
 
 function isPropAccess(node) {
@@ -49,24 +61,40 @@ function isAnySideArgMemberExp(exp, paramName) {
 }
 
 function isEqEqEqToParamMember(exp, paramName) {
-    return exp.type === 'BinaryExpression' && exp.operator === '===' && isAnySideArgMemberExp(exp, paramName);
+    return exp && exp.type === 'BinaryExpression' && exp.operator === '===' && isAnySideArgMemberExp(exp, paramName);
 }
 function isNotEqEqToParamMember(exp, paramName) {
-    return exp.type === 'BinaryExpression' && exp.operator === '!==' && isAnySideArgMemberExp(exp, paramName);
+    return exp && exp.type === 'BinaryExpression' && exp.operator === '!==' && isAnySideArgMemberExp(exp, paramName);
 }
 
 function isNegationExpression(exp) {
-    return exp.type === 'UnaryExpression' && exp.operator === '!';
+    return exp && exp.type === 'UnaryExpression' && exp.operator === '!';
 }
 
 function isNegationOfParamMember(exp, firstParamName) {
     return isNegationExpression(exp) && isMemberExpOfArg(exp.argument, firstParamName);
 }
 
 function isIdentifierOfParam(exp, paramName) {
-    return paramName && exp.type === 'Identifier' && exp.name === paramName;
+    return exp && paramName && exp.type === 'Identifier' && exp.name === paramName;
 }
 
+function getValueReturnedInFirstLine(func) {
+    var firstLine = getFirstFunctionLine(func);
+    if (func) {
+        if (isFunctionDefinitionWithBlock(func)) {
+            return isReturnStatement(firstLine) ? firstLine.argument : null;
+        }
+        if (func.type === 'ArrowFunctionExpression') {
+            return firstLine;
+        }
+    }
+    return null;
+}
+
+function isCallFromObject(node, objName) {
+    return node && node.type === 'CallExpression' && _.get(node, 'callee.object.name') === objName;
+}
 
 module.exports = {
     getCaller: getCaller,
@@ -75,12 +103,13 @@ module.exports = {
     getFirstFunctionLine: getFirstFunctionLine,
     isMemberExpOfArg: isMemberExpOfArg,
     getFirstParamName: getFirstParamName,
-    isReturnStatement: isReturnStatement,
     hasOnlyOneStatement: hasOnlyOneStatement,
     isObjectOfMethodCall: isObjectOfMethodCall,
     isEqEqEqToParamMember: isEqEqEqToParamMember,
     isNotEqEqToParamMember: isNotEqEqToParamMember,
     isNegationOfParamMember: isNegationOfParamMember,
     isIdentifierOfParam: isIdentifierOfParam,
-    isNegationExpression: isNegationExpression
+    isNegationExpression: isNegationExpression,
+    getValueReturnedInFirstLine: getValueReturnedInFirstLine,
+    isCallFromObject: isCallFromObject
 };

lib/util/lodashUtil.js

@@ -4,7 +4,7 @@ var aliasMap = require('./aliases');
 var astUtil = require('./astUtil');
 
 function isLodashCall(node) {
-    return node && node.type === 'CallExpression' && _.get(astUtil.getCaller(node), 'name') === '_';
+    return astUtil.isCallFromObject(node, '_');
 }
 
 function isChainable(node) {

tests/lib/rules/matches-prop-shorthand.js

@@ -13,6 +13,7 @@ var RuleTester = require('eslint').RuleTester;
 // ------------------------------------------------------------------------------
 
 var ruleTester = new RuleTester();
+var errors = [{message: 'Prefer matches property syntax'}];
 ruleTester.run('matches-prop-shorthand', rule, {
     valid: [{
         code: 'var isPublic = _.find([], function (i) { return x.id; });'
@@ -26,11 +27,22 @@ ruleTester.run('matches-prop-shorthand', rule, {
         code: 'var isPublic = _.find([], function (i) { return i.id == 3; });'
     }, {
         code: 'var isPublic = _.find([], function (i) { return i[0] === 3; });'
+    }, {
+        code: 'var isPublic = _.find([], i => i[0] === 3);',
+        ecmaFeatures: {arrowFunctions: true}
     }],
 
     invalid: [{
         code: 'var isPublic = _.find([], function (i) { return i.id === 3; });',
-        errors: [{message: 'Prefer matches property syntax'}]
+        errors: errors
+    }, {
+        code: 'var isPublic = _.find(arr, i => i.id === 3)',
+        ecmaFeatures: {arrowFunctions: true},
+        errors: errors
+    }, {
+        code: 'var isPublic = _.find(arr, (i) => {return i.id === 3})',
+        ecmaFeatures: {arrowFunctions: true},
+        errors: errors
     //}, {
     //    TODO: handle this
     //    code: '_.find(arr, function(i){ return i.b.c === compId; });',

tests/lib/rules/prefer-compact.js

@@ -16,6 +16,8 @@ var ruleError = {message: 'Prefer _.compact over filtering of Boolean casting'};
 ruleTester.run('prefer-compact', rule, {
     valid: [{
         code: 'var x = _.filter(arr, function(x) {return f(x) || g(x)})'
+    }, {
+        code: 'var x = _.filter(arr, function(x) {var a = 1; return f(x, a);})'
     }],
     invalid: [{
         code: '_(arr).map(f).filter(function(x) {return x})',
@@ -29,5 +31,9 @@ ruleTester.run('prefer-compact', rule, {
     }, {
         code: '_.filter(arr, function(x) {return Boolean(x) })',
         errors: [ruleError]
+    }, {
+        code: '_.filter(arr, x => !!x)',
+        ecmaFeatures: {arrowFunctions: true},
+        errors: [ruleError]
     }]
 });

tests/lib/rules/prefer-reject.js

@@ -29,5 +29,9 @@ ruleTester.run('prefer-reject', rule, {
     }, {
         code: '_.filter(arr, function(x) {return !x.isSomething})',
         errors: [ruleError]
+    }, {
+        code: '_.filter(arr, x => !x.isSomething)',
+        ecmaFeatures: {arrowFunctions: true},
+        errors: [ruleError]
     }]
 });

tests/lib/rules/prop-shorthand.js

@@ -28,6 +28,8 @@ ruleTester.run('prop-shorthand', rule, {
         code: 'var ids = _.map([], function (i) { return i[k]; });'
     }, {
         code: 'var r = _.map([], function() { return React.PropTypes.object; })'
+    }, {
+        code: 'var r = _.map([])'
     }],
     invalid: [{
         code: 'var ids = _(users).map(function (i) { return i.id; });',
@@ -41,5 +43,9 @@ ruleTester.run('prop-shorthand', rule, {
     }, {
         code: 'var ids = _.map([], function (i) { return i["id"]; });',
         errors: errors
+    }, {
+        code: 'var ids = _.map([], i => i.id);',
+        ecmaFeatures: {arrowFunctions: true},
+        errors: errors
     }]
 });