Improve disallowSpaceAfterBinaryOperators rule

Catch nodes with "VariableDeclarator" type

Author: markelog

lib/rules/disallow-space-after-binary-operators.js

@@ -30,42 +30,6 @@ module.exports.prototype = {
     check: function(file, errors) {
         var operators = this._operatorIndex;
 
-        // 2 + 2, 2 == 2
-        file.iterateNodesByType(
-            ['BinaryExpression', 'AssignmentExpression', 'LogicalExpression'],
-            function(node) {
-                if (operators[node.operator]) {
-                    var indent;
-                    var range = node.right.range[0];
-
-                    if (tokenHelper.isTokenParenthesis(file, range - 1, true)) {
-                        indent = node.operator.length + 1;
-                    } else {
-                        indent = node.operator.length;
-                    }
-
-                    var part = tokenHelper.getTokenByRangeStartIfPunctuator(
-                        file,
-                        range - indent,
-                        node.operator,
-                        true
-                    );
-
-                    if (!part) {
-                        var loc = tokenHelper.findOperatorByRangeStart(
-                            file, node.right.range[0], node.operator, true
-                        ).loc.start;
-
-                        errors.add(
-                            'Operator ' + node.operator + ' should stick to following expression',
-                            loc.line,
-                            tokenHelper.getPointerEntities(loc.column, node.operator.length)
-                        );
-                    }
-                }
-            }
-        );
-
         function errorIfApplicable(token, i, tokens, operator) {
             var nextToken = tokens[i + 1];
 
@@ -80,7 +44,7 @@ module.exports.prototype = {
             }
         }
 
-         // ":" for object property only but not for ternar
+        // ":" for object property only but not for ternar
         if (operators[':']) {
             file.iterateNodesByType(['ObjectExpression'], function(node) {
                 node.properties.forEach(function(prop) {
@@ -103,6 +67,44 @@ module.exports.prototype = {
                 errorIfApplicable(token, i, tokens, operator);
             });
         }
+
+        // For everything else
+        file.iterateNodesByType(
+            ['BinaryExpression', 'AssignmentExpression', 'VariableDeclarator', 'LogicalExpression'],
+            function(node) {
+                var isDec = node.type === 'VariableDeclarator';
+                var operator = isDec ? '=' : node.operator;
+
+                if (!operators[operator] || node.init === null) {
+                    return;
+                }
+
+                var range = (isDec ? node.init : node.right).range[0];
+
+                var indent = tokenHelper.isTokenParenthesis(file, range - 1, true) ?
+                    operator.length + 1 :
+                    operator.length;
+
+                var part = tokenHelper.getTokenByRangeStartIfPunctuator(
+                    file,
+                    range - indent,
+                    operator,
+                    true
+                );
+
+                if (!part) {
+                    var loc = tokenHelper.findOperatorByRangeStart(
+                        file, range, operator, true
+                    ).loc.start;
+
+                    errors.add(
+                        'Operator ' + operator + ' should stick to following expression',
+                        loc.line,
+                        tokenHelper.getPointerEntities(loc.column, operator.length)
+                    );
+                }
+            }
+        );
     }
 
 };

test/rules/disallow-space-after-binary-operators.js

@@ -73,4 +73,20 @@ describe('rules/disallow-space-after-binary-operators', function() {
         checker.configure({ disallowSpaceAfterBinaryOperators: [','] });
         assert(checker.checkString('function test(a, b){}').getErrorCount() === 1);
     });
+    it('should report for assignment expression', function() {
+        checker.configure({ disallowSpaceAfterBinaryOperators: ['='] });
+        assert(checker.checkString('x = 1').getErrorCount() === 1);
+    });
+    it('should report for assignment expressions', function() {
+        checker.configure({ disallowSpaceAfterBinaryOperators: ['='] });
+        assert(checker.checkString('var x = 1, t = 2').getErrorCount() === 2);
+    });
+    it('should not report for assignment expressions if "=" is not specified', function() {
+        checker.configure({ disallowSpaceAfterBinaryOperators: [','] });
+        assert(checker.checkString('var x = 1;').isEmpty());
+    });
+    it('should not report empty assignment expression', function() {
+        checker.configure({ disallowSpaceAfterBinaryOperators: ['='] });
+        assert(checker.checkString('var x').isEmpty());
+    });
 });