eslint 0.22.0 → 0.24.1

package/lib/rules/space-infix-ops.js

@@ -1,106 +1,106 @@
-/**
- * @fileoverview Require spaces around infix operators
- * @author Michael Ficarra
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-    var int32Hint = context.options[0] ? context.options[0].int32Hint === true : false;
-
-    var OPERATORS = [
-        "*", "/", "%", "+", "-", "<<", ">>", ">>>", "<", "<=", ">", ">=", "in",
-        "instanceof", "==", "!=", "===", "!==", "&", "^", "|", "&&", "||", "=",
-        "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "&=", "^=", "|=",
-        "?", ":", ","
-    ];
-
-    /**
-     * Returns the first token which violates the rule
-     * @param {ASTNode} left - The left node of the main node
-     * @param {ASTNode} right - The right node of the main node
-     * @returns {object} The violator token or null
-     * @private
-     */
-    function getFirstNonSpacedToken(left, right) {
-        var op, tokens = context.getTokensBetween(left, right, 1);
-        for (var i = 1, l = tokens.length - 1; i < l; ++i) {
-            op = tokens[i];
-            if (
-                op.type === "Punctuator" &&
-                OPERATORS.indexOf(op.value) >= 0 &&
-                (tokens[i - 1].range[1] >= op.range[0] || op.range[1] >= tokens[i + 1].range[0])
-            ) {
-                return op;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Reports an AST node as a rule violation
-     * @param {ASTNode} mainNode - The node to report
-     * @param {object} culpritToken - The token which has a problem
-     * @returns {void}
-     * @private
-     */
-    function report(mainNode, culpritToken) {
-        context.report(mainNode, culpritToken.loc.start, "Infix operators must be spaced.");
-    }
-
-    function checkBinary(node) {
-        var nonSpacedNode = getFirstNonSpacedToken(node.left, node.right);
-
-        if (nonSpacedNode) {
-            if (!(int32Hint && context.getSource(node).substr(-2) === "|0")) {
-                report(node, nonSpacedNode);
-            }
-        }
-    }
-
-    function checkConditional(node) {
-        var nonSpacedConsequesntNode = getFirstNonSpacedToken(node.test, node.consequent);
-        var nonSpacedAlternateNode = getFirstNonSpacedToken(node.consequent, node.alternate);
-
-        if (nonSpacedConsequesntNode) {
-            report(node, nonSpacedConsequesntNode);
-        } else if (nonSpacedAlternateNode) {
-            report(node, nonSpacedAlternateNode);
-        }
-    }
-
-    function checkVar(node) {
-        var nonSpacedNode;
-
-        if (node.init) {
-            nonSpacedNode = getFirstNonSpacedToken(node.id, node.init);
-            if (nonSpacedNode) {
-                report(node, nonSpacedNode);
-            }
-        }
-    }
-
-    return {
-        "AssignmentExpression": checkBinary,
-        "BinaryExpression": checkBinary,
-        "LogicalExpression": checkBinary,
-        "ConditionalExpression": checkConditional,
-        "VariableDeclarator": checkVar
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "type": "object",
-        "properties": {
-            "int32Hint": {
-                "type": "boolean"
-            }
-        },
-        "additionalProperties": false
-    }
-];
+/**
+ * @fileoverview Require spaces around infix operators
+ * @author Michael Ficarra
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+    var int32Hint = context.options[0] ? context.options[0].int32Hint === true : false;
+
+    var OPERATORS = [
+        "*", "/", "%", "+", "-", "<<", ">>", ">>>", "<", "<=", ">", ">=", "in",
+        "instanceof", "==", "!=", "===", "!==", "&", "^", "|", "&&", "||", "=",
+        "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "&=", "^=", "|=",
+        "?", ":", ","
+    ];
+
+    /**
+     * Returns the first token which violates the rule
+     * @param {ASTNode} left - The left node of the main node
+     * @param {ASTNode} right - The right node of the main node
+     * @returns {object} The violator token or null
+     * @private
+     */
+    function getFirstNonSpacedToken(left, right) {
+        var op, tokens = context.getTokensBetween(left, right, 1);
+        for (var i = 1, l = tokens.length - 1; i < l; ++i) {
+            op = tokens[i];
+            if (
+                op.type === "Punctuator" &&
+                OPERATORS.indexOf(op.value) >= 0 &&
+                (tokens[i - 1].range[1] >= op.range[0] || op.range[1] >= tokens[i + 1].range[0])
+            ) {
+                return op;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Reports an AST node as a rule violation
+     * @param {ASTNode} mainNode - The node to report
+     * @param {object} culpritToken - The token which has a problem
+     * @returns {void}
+     * @private
+     */
+    function report(mainNode, culpritToken) {
+        context.report(mainNode, culpritToken.loc.start, "Infix operators must be spaced.");
+    }
+
+    function checkBinary(node) {
+        var nonSpacedNode = getFirstNonSpacedToken(node.left, node.right);
+
+        if (nonSpacedNode) {
+            if (!(int32Hint && context.getSource(node).substr(-2) === "|0")) {
+                report(node, nonSpacedNode);
+            }
+        }
+    }
+
+    function checkConditional(node) {
+        var nonSpacedConsequesntNode = getFirstNonSpacedToken(node.test, node.consequent);
+        var nonSpacedAlternateNode = getFirstNonSpacedToken(node.consequent, node.alternate);
+
+        if (nonSpacedConsequesntNode) {
+            report(node, nonSpacedConsequesntNode);
+        } else if (nonSpacedAlternateNode) {
+            report(node, nonSpacedAlternateNode);
+        }
+    }
+
+    function checkVar(node) {
+        var nonSpacedNode;
+
+        if (node.init) {
+            nonSpacedNode = getFirstNonSpacedToken(node.id, node.init);
+            if (nonSpacedNode) {
+                report(node, nonSpacedNode);
+            }
+        }
+    }
+
+    return {
+        "AssignmentExpression": checkBinary,
+        "BinaryExpression": checkBinary,
+        "LogicalExpression": checkBinary,
+        "ConditionalExpression": checkConditional,
+        "VariableDeclarator": checkVar
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "type": "object",
+        "properties": {
+            "int32Hint": {
+                "type": "boolean"
+            }
+        },
+        "additionalProperties": false
+    }
+];

package/lib/rules/space-return-throw-case.js

@@ -1,38 +1,38 @@
-/**
- * @fileoverview Require spaces following return, throw, and case
- * @author Michael Ficarra
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    function check(node) {
-        var tokens = context.getFirstTokens(node, 2),
-            value = tokens[0].value;
-
-        if (tokens[0].range[1] >= tokens[1].range[0]) {
-            context.report(node, "Keyword \"" + value + "\" must be followed by whitespace.");
-        }
-    }
-
-    return {
-        "ReturnStatement": function(node) {
-            if (node.argument) {
-                check(node);
-            }
-        },
-        "SwitchCase": function(node) {
-            if (node.test) {
-                check(node);
-            }
-        },
-        "ThrowStatement": check
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Require spaces following return, throw, and case
+ * @author Michael Ficarra
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    function check(node) {
+        var tokens = context.getFirstTokens(node, 2),
+            value = tokens[0].value;
+
+        if (tokens[0].range[1] >= tokens[1].range[0]) {
+            context.report(node, "Keyword \"" + value + "\" must be followed by whitespace.");
+        }
+    }
+
+    return {
+        "ReturnStatement": function(node) {
+            if (node.argument) {
+                check(node);
+            }
+        },
+        "SwitchCase": function(node) {
+            if (node.test) {
+                check(node);
+            }
+        },
+        "ThrowStatement": check
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/space-unary-ops.js

@@ -1,133 +1,124 @@
-/**
- * @fileoverview This rule shoud require or disallow spaces before or after unary operations.
- * @author Marcin Kumorek
- * @copyright 2014 Marcin Kumorek. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-    var options = context.options && Array.isArray(context.options) && context.options[0] || { words: true, nonwords: false };
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /**
-    * Check if the parent unary operator is "!" in order to know if it's "!!" convert to Boolean or just "!" negation
-    * @param {ASTnode} node AST node
-    * @returns {boolean} Whether or not the parent is unary "!" operator
-    */
-    function isParentUnaryBangExpression(node) {
-        return node && node.parent && node.parent.type === "UnaryExpression" && node.parent.operator === "!";
-    }
-
-    /**
-    * Checks if the type is a unary word expression
-    * @param {string} type value of AST token
-    * @returns {boolean} Whether the word is in the list of known words
-    */
-    function isWordExpression(type) {
-        return ["delete", "new", "typeof", "void"].indexOf(type) !== -1;
-    }
-
-    /**
-    * Check if the node's child argument is an "ObjectExpression"
-    * @param {ASTnode} node AST node
-    * @returns {boolean} Whether or not the argument's type is "ObjectExpression"
-    */
-    function isArgumentObjectExpression(node) {
-        return node.argument && node.argument.type && node.argument.type === "ObjectExpression";
-    }
-
-    /**
-    * Check Unary Word Operators for spaces after the word operator
-    * @param {ASTnode} node AST node
-    * @param {object} firstToken first token from the AST node
-    * @param {object} secondToken second token from the AST node
-    * @returns {void}
-    */
-    function checkUnaryWordOperatorForSpaces(node, firstToken, secondToken) {
-        if (options.words) {
-            if (secondToken.range[0] === firstToken.range[1]) {
-                context.report(node, "Unary word operator \"" + firstToken.value + "\" must be followed by whitespace.");
-            }
-        }
-
-        if (!options.words && isArgumentObjectExpression(node)) {
-            if (secondToken.range[0] > firstToken.range[1]) {
-                context.report(node, "Unexpected space after unary word operator \"" + firstToken.value + "\".");
-            }
-        }
-    }
-
-    /**
-    * Checks UnaryExpression, UpdateExpression and NewExpression for spaces before and after the operator
-    * @param {ASTnode} node AST node
-    * @returns {void}
-    */
-    function checkForSpaces(node) {
-        var tokens = context.getFirstTokens(node, 2),
-            firstToken = tokens[0],
-            secondToken = tokens[1];
-
-        if (isWordExpression(firstToken.value)) {
-            checkUnaryWordOperatorForSpaces(node, firstToken, secondToken);
-            return void 0;
-        }
-
-        if (options.nonwords) {
-            if (node.prefix) {
-                if (isParentUnaryBangExpression(node)) {
-                    return void 0;
-                }
-                if (firstToken.range[1] === secondToken.range[0]) {
-                    context.report(node, "Unary operator \"" + firstToken.value + "\" must be followed by whitespace.");
-                }
-            } else {
-                if (firstToken.range[1] === secondToken.range[0]) {
-                    context.report(node, "Space is required before unary expressions \"" + secondToken.value + "\".");
-                }
-            }
-        } else {
-            if (node.prefix) {
-                if (secondToken.range[0] > firstToken.range[1]) {
-                    context.report(node, "Unexpected space after unary operator \"" + firstToken.value + "\".");
-                }
-            } else {
-                if (secondToken.range[0] > firstToken.range[1]) {
-                    context.report(node, "Unexpected space before unary operator \"" + secondToken.value + "\".");
-                }
-            }
-        }
-    }
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    return {
-        "UnaryExpression": checkForSpaces,
-        "UpdateExpression": checkForSpaces,
-        "NewExpression": checkForSpaces
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "type": "object",
-        "properties": {
-            "words": {
-                "type": "boolean"
-            },
-            "nonwords": {
-                "type": "boolean"
-            }
-        },
-        "additionalProperties": false
-    }
-];
+/**
+ * @fileoverview This rule shoud require or disallow spaces before or after unary operations.
+ * @author Marcin Kumorek
+ * @copyright 2014 Marcin Kumorek. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+    var options = context.options && Array.isArray(context.options) && context.options[0] || { words: true, nonwords: false };
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+    * Check if the parent unary operator is "!" in order to know if it's "!!" convert to Boolean or just "!" negation
+    * @param {ASTnode} node AST node
+    * @returns {boolean} Whether or not the parent is unary "!" operator
+    */
+    function isParentUnaryBangExpression(node) {
+        return node && node.parent && node.parent.type === "UnaryExpression" && node.parent.operator === "!";
+    }
+
+    /**
+    * Check if the node's child argument is an "ObjectExpression"
+    * @param {ASTnode} node AST node
+    * @returns {boolean} Whether or not the argument's type is "ObjectExpression"
+    */
+    function isArgumentObjectExpression(node) {
+        return node.argument && node.argument.type && node.argument.type === "ObjectExpression";
+    }
+
+    /**
+    * Check Unary Word Operators for spaces after the word operator
+    * @param {ASTnode} node AST node
+    * @param {object} firstToken first token from the AST node
+    * @param {object} secondToken second token from the AST node
+    * @returns {void}
+    */
+    function checkUnaryWordOperatorForSpaces(node, firstToken, secondToken) {
+        if (options.words) {
+            if (secondToken.range[0] === firstToken.range[1]) {
+                context.report(node, "Unary word operator \"" + firstToken.value + "\" must be followed by whitespace.");
+            }
+        }
+
+        if (!options.words && isArgumentObjectExpression(node)) {
+            if (secondToken.range[0] > firstToken.range[1]) {
+                context.report(node, "Unexpected space after unary word operator \"" + firstToken.value + "\".");
+            }
+        }
+    }
+
+    /**
+    * Checks UnaryExpression, UpdateExpression and NewExpression for spaces before and after the operator
+    * @param {ASTnode} node AST node
+    * @returns {void}
+    */
+    function checkForSpaces(node) {
+        var tokens = context.getFirstTokens(node, 2),
+            firstToken = tokens[0],
+            secondToken = tokens[1];
+
+        if ((node.type === "NewExpression" || node.prefix) && firstToken.type === "Keyword") {
+            checkUnaryWordOperatorForSpaces(node, firstToken, secondToken);
+            return void 0;
+        }
+
+        if (options.nonwords) {
+            if (node.prefix) {
+                if (isParentUnaryBangExpression(node)) {
+                    return void 0;
+                }
+                if (firstToken.range[1] === secondToken.range[0]) {
+                    context.report(node, "Unary operator \"" + firstToken.value + "\" must be followed by whitespace.");
+                }
+            } else {
+                if (firstToken.range[1] === secondToken.range[0]) {
+                    context.report(node, "Space is required before unary expressions \"" + secondToken.value + "\".");
+                }
+            }
+        } else {
+            if (node.prefix) {
+                if (secondToken.range[0] > firstToken.range[1]) {
+                    context.report(node, "Unexpected space after unary operator \"" + firstToken.value + "\".");
+                }
+            } else {
+                if (secondToken.range[0] > firstToken.range[1]) {
+                    context.report(node, "Unexpected space before unary operator \"" + secondToken.value + "\".");
+                }
+            }
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+        "UnaryExpression": checkForSpaces,
+        "UpdateExpression": checkForSpaces,
+        "NewExpression": checkForSpaces
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "type": "object",
+        "properties": {
+            "words": {
+                "type": "boolean"
+            },
+            "nonwords": {
+                "type": "boolean"
+            }
+        },
+        "additionalProperties": false
+    }
+];