eslint 1.7.1 → 1.9.0

package/lib/rules/comma-spacing.js

@@ -41,42 +41,6 @@ module.exports = function(context) {
         return !!token && (token.type === "Punctuator") && (token.value === ",");
     }
 
-    /**
-     * Reports a spacing error with an appropriate message.
-     * @param {ASTNode} node The binary expression node to report.
-     * @param {string} dir Is the error "before" or "after" the comma?
-     * @returns {void}
-     * @private
-     */
-    function report(node, dir) {
-        context.report(node, options[dir] ?
-            "A space is required " + dir + " ','." :
-            "There should be no space " + dir + " ','.");
-    }
-
-    /**
-     * Validates the spacing around a comma token.
-     * @param {Object} tokens - The tokens to be validated.
-     * @param {Token} tokens.comma The token representing the comma.
-     * @param {Token} [tokens.left] The last token before the comma.
-     * @param {Token} [tokens.right] The first token after the comma.
-     * @param {Token|ASTNode} reportItem The item to use when reporting an error.
-     * @returns {void}
-     * @private
-     */
-    function validateCommaItemSpacing(tokens, reportItem) {
-        if (tokens.left && astUtils.isTokenOnSameLine(tokens.left, tokens.comma) &&
-                (options.before !== sourceCode.isSpaceBetweenTokens(tokens.left, tokens.comma))
-        ) {
-            report(reportItem, "before");
-        }
-        if (tokens.right && astUtils.isTokenOnSameLine(tokens.comma, tokens.right) &&
-                (options.after !== sourceCode.isSpaceBetweenTokens(tokens.comma, tokens.right))
-        ) {
-            report(reportItem, "after");
-        }
-    }
-
     /**
      * Determines if a given source index is in a comment or not by checking
      * the index against the comment range. Since the check goes straight
@@ -90,6 +54,7 @@ module.exports = function(context) {
     function isIndexInComment(index, comments) {
 
         var comment;
+        lastCommentIndex = 0;
 
         while (lastCommentIndex < comments.length) {
 
@@ -108,6 +73,77 @@ module.exports = function(context) {
         return false;
     }
 
+
+    /**
+     * Reports a spacing error with an appropriate message.
+     * @param {ASTNode} node The binary expression node to report.
+     * @param {string} dir Is the error "before" or "after" the comma?
+     * @param {ASTNode} otherNode The node at the left or right of `node`
+     * @returns {void}
+     * @private
+     */
+    function report(node, dir, otherNode) {
+        context.report({
+            node: node,
+            fix: function(fixer) {
+                if (options[dir]) {
+                    if (dir === "before") {
+                        return fixer.insertTextBefore(node, " ");
+                    } else {
+                        return fixer.insertTextAfter(node, " ");
+                    }
+                } else {
+                    /*
+                     * Comments handling
+                     */
+                    var start, end;
+                    var newText = "";
+
+                    if (dir === "before") {
+                        start = otherNode.range[1];
+                        end = node.range[0];
+                    } else {
+                        start = node.range[1];
+                        end = otherNode.range[0];
+                    }
+
+                    for (var i = start; i < end; i++) {
+                        if (isIndexInComment(i, allComments)) {
+                            newText += context.getSource()[i];
+                        }
+                    }
+                    return fixer.replaceTextRange([start, end], newText);
+                }
+            },
+            message: options[dir] ?
+              "A space is required " + dir + " ','." :
+              "There should be no space " + dir + " ','."
+        });
+    }
+
+    /**
+     * Validates the spacing around a comma token.
+     * @param {Object} tokens - The tokens to be validated.
+     * @param {Token} tokens.comma The token representing the comma.
+     * @param {Token} [tokens.left] The last token before the comma.
+     * @param {Token} [tokens.right] The first token after the comma.
+     * @param {Token|ASTNode} reportItem The item to use when reporting an error.
+     * @returns {void}
+     * @private
+     */
+    function validateCommaItemSpacing(tokens, reportItem) {
+        if (tokens.left && astUtils.isTokenOnSameLine(tokens.left, tokens.comma) &&
+                (options.before !== sourceCode.isSpaceBetweenTokens(tokens.left, tokens.comma))
+        ) {
+            report(reportItem, "before", tokens.left);
+        }
+        if (tokens.right && astUtils.isTokenOnSameLine(tokens.comma, tokens.right) &&
+                (options.after !== sourceCode.isSpaceBetweenTokens(tokens.comma, tokens.right))
+        ) {
+            report(reportItem, "after", tokens.right);
+        }
+    }
+
     /**
      * Adds null elements of the given ArrayExpression or ArrayPattern node to the ignore list.
      * @param {ASTNode} node An ArrayExpression or ArrayPattern node.

package/lib/rules/eol-last.js

@@ -18,8 +18,10 @@ module.exports = function(context) {
 
         "Program": function checkBadEOF(node) {
             // Get the whole source code, not for node only.
-            var src = context.getSource(), location = {column: 1};
-
+            var src = context.getSource(),
+                location = {column: 1},
+                linebreakStyle = context.options[0] || "unix",
+                linebreak = linebreakStyle === "unix" ? "\n" : "\r\n";
             if (src.length === 0) {
                 return;
             }
@@ -32,7 +34,7 @@ module.exports = function(context) {
                     loc: location,
                     message: "Newline required at end of file but not found.",
                     fix: function(fixer) {
-                        return fixer.insertTextAfterRange([0, src.length], "\n");
+                        return fixer.insertTextAfterRange([0, src.length], linebreak);
                     }
                 });
             }
@@ -42,4 +44,8 @@ module.exports = function(context) {
 
 };
 
-module.exports.schema = [];
+module.exports.schema = [
+    {
+        "enum": ["unix", "windows"]
+    }
+];

package/lib/rules/indent.js

@@ -284,15 +284,16 @@ module.exports = function(context) {
     }
 
     /**
-     * Check to see if the node arguments are spread across multiple lines
+     * Check to see if the argument before the callee node is multi-line and
+     * there should only be 1 argument before the callee node
      * @param {ASTNode} node node to check
      * @returns {boolean} True if arguments are multi-line
      */
-    function isCallArgsMultiline(node) {
-        var lastArg = node.arguments.length > 0 ? node.arguments[node.arguments.length - 1] : null;
+    function isArgBeforeCalleeNodeMultiline(node) {
+        var parent = node.parent;
 
-        if (lastArg) {
-            return lastArg.loc.end.line > node.loc.start.line;
+        if (parent.arguments.length >= 2 && parent.arguments[1] === node) {
+            return parent.arguments[0].loc.end.line > parent.arguments[0].loc.start.line;
         }
 
         return false;
@@ -337,7 +338,7 @@ module.exports = function(context) {
                     indent = getNodeIndent(calleeParent);
                 }
             } else {
-                if (isCallArgsMultiline(calleeParent) &&
+                if (isArgBeforeCalleeNodeMultiline(calleeNode) &&
                     calleeParent.callee.loc.start.line === calleeParent.callee.loc.end.line &&
                     !isNodeFirstInLine(calleeNode)) {
                     indent = getNodeIndent(calleeParent);
@@ -435,7 +436,7 @@ module.exports = function(context) {
                 } else if (parent.loc.start.line !== node.loc.start.line && parentVarNode === parentVarNode.parent.declarations[0]) {
                     nodeIndent = nodeIndent + indentSize;
                 }
-            } else if (!parentVarNode && !isFirstArrayElementOnSameLine(parent) && effectiveParent.type !== "ExpressionStatement" && effectiveParent.type !== "AssignmentExpression" && effectiveParent.type !== "Property") {
+            } else if (!parentVarNode && !isFirstArrayElementOnSameLine(parent) && effectiveParent.type !== "MemberExpression" && effectiveParent.type !== "ExpressionStatement" && effectiveParent.type !== "AssignmentExpression" && effectiveParent.type !== "Property") {
                 nodeIndent = nodeIndent + indentSize;
             }
 

package/lib/rules/key-spacing.js

@@ -98,31 +98,13 @@ module.exports = function(context) {
         beforeColon = +!!options.beforeColon, // Defaults to false
         afterColon = +!(options.afterColon === false); // Defaults to true
 
-    /**
-     * Gets the first node on the same line with the provided node.
-     * @param {ASTNode} node The node to check find from
-     * @returns {ASTNode} the first node on the given node's line
-     */
-    function getFirstNodeInLine(node) {
-        var startLine, endLine, firstToken = node;
-
-        do {
-            node = firstToken;
-            firstToken = context.getTokenBefore(node);
-            startLine = node.loc.start.line;
-            endLine = firstToken ? firstToken.loc.end.line : -1;
-        } while (startLine === endLine);
-
-        return node;
-    }
-
     /**
      * Starting from the given a node (a property.key node here) looks forward
-     * until it finds the first node before a colon punctuator and returns it.
-     * @param {ASTNode} node The node to start looking from
-     * @returns {ASTNode} the first node before a colon punctuator
+     * until it finds the last token before a colon punctuator and returns it.
+     * @param {ASTNode} node The node to start looking from.
+     * @returns {ASTNode} The last token before a colon punctuator.
      */
-    function getFirstNodeBeforeColon(node) {
+    function getLastTokenBeforeColon(node) {
         var prevNode;
 
         while (node && (node.type !== "Punctuator" || node.value !== ":")) {
@@ -181,9 +163,15 @@ module.exports = function(context) {
      * @returns {int} Width of the key.
      */
     function getKeyWidth(property) {
-        var key = property.key;
-        var startToken = getFirstNodeInLine(key);
-        var endToken = getFirstNodeBeforeColon(key);
+        var startToken, endToken;
+
+        // Ignore shorthand methods and properties, as they have no colon
+        if (property.method || property.shorthand) {
+            return 0;
+        }
+
+        startToken = context.getFirstToken(property);
+        endToken = getLastTokenBeforeColon(property.key);
 
         return endToken.range[1] - startToken.range[0];
     }

package/lib/rules/linebreak-style.js

@@ -13,25 +13,60 @@
 //------------------------------------------------------------------------------
 
 module.exports = function(context) {
+
     var EXPECTED_LF_MSG = "Expected linebreaks to be 'LF' but found 'CRLF'.",
         EXPECTED_CRLF_MSG = "Expected linebreaks to be 'CRLF' but found 'LF'.";
 
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Builds a fix function that replaces text at the specified range in the source text.
+     * @param {int[]} range The range to replace
+     * @param {string} text The text to insert.
+     * @returns {function} Fixer function
+     * @private
+     */
+    function createFix(range, text) {
+        return function(fixer) {
+            return fixer.replaceTextRange(range, text);
+        };
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
     return {
         "Program": function checkForlinebreakStyle(node) {
             var linebreakStyle = context.options[0] || "unix",
                 expectedLF = linebreakStyle === "unix",
-                linebreaks = context.getSource().match(/\r\n|\r|\n|\u2028|\u2029/g),
-                lineOfError = -1;
+                expectedLFChars = expectedLF ? "\n" : "\r\n",
+                source = context.getSource(),
+                pattern = /\r\n|\r|\n|\u2028|\u2029/g,
+                match,
+                index,
+                range;
 
-            if (linebreaks !== null) {
-                lineOfError = linebreaks.indexOf(expectedLF ? "\r\n" : "\n");
-            }
+            var i = 0;
+            while ((match = pattern.exec(source)) !== null) {
+                i++;
+                if (match[0] === expectedLFChars) {
+                    continue;
+                }
 
-            if (lineOfError !== -1) {
-                context.report(node, {
-                    line: lineOfError + 1,
-                    column: context.getSourceLines()[lineOfError].length
-                }, expectedLF ? EXPECTED_LF_MSG : EXPECTED_CRLF_MSG);
+                index = match.index;
+                range = [index, index + match[0].length];
+                context.report({
+                    node: node,
+                    loc: {
+                        line: i,
+                        column: context.getSourceLines()[i - 1].length
+                    },
+                    message: expectedLF ? EXPECTED_LF_MSG : EXPECTED_CRLF_MSG,
+                    fix: createFix(range, expectedLFChars)
+                });
             }
         }
     };

package/lib/rules/max-nested-callbacks.js

@@ -16,7 +16,7 @@ module.exports = function(context) {
     // Constants
     //--------------------------------------------------------------------------
 
-    var THRESHOLD = context.options[0];
+    var THRESHOLD = context.options[0] || 10;
 
     //--------------------------------------------------------------------------
     // Helpers

package/lib/rules/no-arrow-condition.js

@@ -0,0 +1,88 @@
+/**
+ * @fileoverview A rule to warn against using arrow functions in conditions.
+ * @author Jxck <https://github.com/Jxck>
+ * @copyright 2015 Luke Karrys. All rights reserved.
+ * The MIT License (MIT)
+
+ * Copyright (c) 2015 Jxck
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether or not a node is an arrow function expression.
+ * @param {ASTNode} node - node to test
+ * @returns {boolean} `true` if the node is an arrow function expression.
+ */
+function isArrowFunction(node) {
+    return node.test && node.test.type === "ArrowFunctionExpression";
+}
+
+/**
+ * Checks whether or not a node is a conditional expression.
+ * @param {ASTNode} node - node to test
+ * @returns {boolean} `true` if the node is a conditional expression.
+ */
+function isConditional(node) {
+    return node.body && node.body.type === "ConditionalExpression";
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+    /**
+     * Reports if a conditional statement is an arrow function.
+     * @param {ASTNode} node - A node to check and report.
+     * @returns {void}
+     */
+    function checkCondition(node) {
+        if (isArrowFunction(node)) {
+            context.report(node, "Arrow function `=>` used inside {{statementType}} instead of comparison operator.", {statementType: node.type});
+        }
+    }
+
+    /**
+     * Reports if an arrow function contains an ambiguous conditional.
+     * @param {ASTNode} node - A node to check and report.
+     * @returns {void}
+     */
+    function checkArrowFunc(node) {
+        if (isConditional(node)) {
+            context.report(node, "Arrow function used ambiguously with a conditional expression.");
+        }
+    }
+
+    return {
+        "IfStatement": checkCondition,
+        "WhileStatement": checkCondition,
+        "ForStatement": checkCondition,
+        "ConditionalExpression": checkCondition,
+        "ArrowFunctionExpression": checkArrowFunc
+    };
+};
+
+module.exports.schema = [];

package/lib/rules/no-case-declarations.js

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Rule to flag use of an lexical declarations inside a case clause
+ * @author Erik Arvidsson
+ * @copyright 2015 Erik Arvidsson. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Checks whether or not a node is a lexical declaration.
+     * @param {ASTNode} node A direct child statement of a switch case.
+     * @returns {boolean} Whether or not the node is a lexical declaration.
+     */
+    function isLexicalDeclaration(node) {
+        switch (node.type) {
+            case "FunctionDeclaration":
+            case "ClassDeclaration":
+                return true;
+            case "VariableDeclaration":
+                return node.kind !== "var";
+            default:
+                return false;
+        }
+    }
+
+    return {
+        "SwitchCase": function(node) {
+            for (var i = 0; i < node.consequent.length; i++) {
+                var statement = node.consequent[i];
+                if (isLexicalDeclaration(statement)) {
+                    context.report({
+                        node: node,
+                        message: "Unexpected lexical declaration in case block."
+                    });
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-extend-native.js

@@ -54,17 +54,17 @@ module.exports = function(context) {
             });
         },
 
-        // handle the Object.defineProperty(Array.prototype) case
+        // handle the Object.definePropert[y|ies](Array.prototype) case
         "CallExpression": function(node) {
 
             var callee = node.callee,
                 subject,
                 object;
 
-            // only worry about Object.defineProperty
+            // only worry about Object.definePropert[y|ies]
             if (callee.type === "MemberExpression" &&
                 callee.object.name === "Object" &&
-                callee.property.name === "defineProperty") {
+                (callee.property.name === "defineProperty" || callee.property.name === "defineProperties")) {
 
                 // verify the object being added to is a native prototype
                 subject = node.arguments[0];

package/lib/rules/no-magic-numbers.js

@@ -63,15 +63,32 @@ module.exports = function(context) {
     return {
         "Literal": function(node) {
             var parent = node.parent,
+                value = node.value,
+                raw = node.raw,
                 okTypes = detectObjects ? [] : ["ObjectExpression", "Property", "AssignmentExpression"];
 
-            // don't warn on parseInt() radix
-            if (node.parent.type === "CallExpression" && node === node.parent.arguments[1] &&
-                    node.parent.callee.name === "parseInt") {
+            if (!isNumber(node)) {
                 return;
             }
 
-            if (!isNumber(node) || shouldIgnoreNumber(node.value)) {
+            if (parent.type === "UnaryExpression" && parent.operator === "-") {
+                node = parent;
+                parent = node.parent;
+                value = -value;
+                raw = "-" + raw;
+            }
+
+            if (shouldIgnoreNumber(value)) {
+                return;
+            }
+
+            // don't warn on parseInt() or Number.parseInt() radix
+            if (parent.type === "CallExpression" && node === parent.arguments[1] &&
+                    (parent.callee.name === "parseInt" ||
+                    parent.callee.type === "MemberExpression" &&
+                    parent.callee.object.name === "Number" &&
+                    parent.callee.property.name === "parseInt")
+            ) {
                 return;
             }
 
@@ -85,7 +102,7 @@ module.exports = function(context) {
             } else if (okTypes.indexOf(parent.type) === -1) {
                 context.report({
                     node: node,
-                    message: "No magic number: " + node.raw
+                    message: "No magic number: " + raw
                 });
             }
         }

package/lib/rules/no-mixed-spaces-and-tabs.js

@@ -14,9 +14,7 @@
 module.exports = function(context) {
 
     var smartTabs,
-        templateLocs = [],
-        lastTemplateLocIndex = 0,
-        lastCommentLocIndex = 0;
+        ignoredLocs = [];
 
     switch (context.options[0]) {
         case true: // Support old syntax, maybe add deprecation warning here
@@ -64,7 +62,7 @@ module.exports = function(context) {
     return {
 
         "TemplateElement": function(node) {
-            templateLocs.push(node.loc);
+            ignoredLocs.push(node.loc);
         },
 
         "Program:exit": function(node) {
@@ -78,6 +76,22 @@ module.exports = function(context) {
                 lines = context.getSourceLines(),
                 comments = context.getAllComments();
 
+            comments.forEach(function(comment) {
+                ignoredLocs.push(comment.loc);
+            });
+
+            ignoredLocs.sort(function(first, second) {
+                if (beforeLoc(first, second.start.line, second.start.column)) {
+                    return 1;
+                }
+
+                if (beforeLoc(second, first.start.line, second.start.column)) {
+                    return -1;
+                }
+
+                return 0;
+            });
+
             if (smartTabs) {
                 /*
                  * At least one space followed by a tab
@@ -93,28 +107,18 @@ module.exports = function(context) {
                     var lineNumber = i + 1,
                         column = match.index + 1;
 
-                    for (; lastCommentLocIndex < comments.length; lastCommentLocIndex++) {
-                        if (beforeLoc(comments[lastCommentLocIndex].loc, lineNumber, column)) {
+                    for (var j = 0; j < ignoredLocs.length; j++) {
+                        if (beforeLoc(ignoredLocs[j], lineNumber, column)) {
                             continue;
                         }
-                        if (afterLoc(comments[lastCommentLocIndex].loc, lineNumber, column)) {
-                            break;
-                        }
-                        return;
-                    }
-
-                    // make sure this isn't inside of a template element
-                    for (; lastTemplateLocIndex < templateLocs.length; lastTemplateLocIndex++) {
-                        if (beforeLoc(templateLocs[lastTemplateLocIndex], lineNumber, column)) {
+                        if (afterLoc(ignoredLocs[j], lineNumber, column)) {
                             continue;
                         }
-                        if (afterLoc(templateLocs[lastTemplateLocIndex], lineNumber, column)) {
-                            break;
-                        }
+
                         return;
                     }
 
-                    context.report(node, { line: i + 1, column: column }, "Mixed spaces and tabs.");
+                    context.report(node, { line: lineNumber, column: column }, "Mixed spaces and tabs.");
                 }
             });
         }