eslint 1.9.0 → 1.10.3

package/lib/options.js

@@ -112,7 +112,7 @@ module.exports = optionator({
         },
         {
             option: "ignore-pattern",
-            type: "String",
+            type: "[String]",
             description: "Pattern of files to ignore (in addition to those in .eslintignore)"
         },
         {
@@ -198,6 +198,12 @@ module.exports = optionator({
             alias: "v",
             type: "Boolean",
             description: "Outputs the version number"
+        },
+        {
+            option: "inline-config",
+            type: "Boolean",
+            default: "true",
+            description: "Allow comments to change eslint config/rules"
         }
     ]
 });

package/lib/rules/block-spacing.js

@@ -59,8 +59,8 @@ module.exports = function(context) {
         // Gets braces and the first/last token of content.
         var openBrace = getOpenBrace(node);
         var closeBrace = context.getLastToken(node);
-        var firstToken = context.getTokenAfter(openBrace);
-        var lastToken = context.getTokenBefore(closeBrace);
+        var firstToken = sourceCode.getTokenOrCommentAfter(openBrace);
+        var lastToken = sourceCode.getTokenOrCommentBefore(closeBrace);
 
         // Skip if the node is invalid or empty.
         if (openBrace.type !== "Punctuator" ||
@@ -72,6 +72,11 @@ module.exports = function(context) {
             return;
         }
 
+        // Skip line comments for option never
+        if (!always && firstToken.type === "Line") {
+            return;
+        }
+
         // Check.
         if (!isValid(openBrace, firstToken)) {
             context.report({

package/lib/rules/brace-style.js

@@ -109,7 +109,9 @@ module.exports = function(context) {
                 tokens = context.getTokensBefore(node.alternate, 2);
 
                 if (style === "1tbs") {
-                    if (tokens[0].loc.start.line !== tokens[1].loc.start.line && isCurlyPunctuator(tokens[0]) ) {
+                    if (tokens[0].loc.start.line !== tokens[1].loc.start.line &&
+                        node.consequent.type === "BlockStatement" &&
+                        isCurlyPunctuator(tokens[0]) ) {
                         context.report(node.alternate, CLOSE_MESSAGE);
                     }
                 } else if (tokens[0].loc.start.line === tokens[1].loc.start.line) {

package/lib/rules/comma-spacing.js

@@ -14,6 +14,7 @@ var astUtils = require("../ast-utils");
 module.exports = function(context) {
 
     var sourceCode = context.getSourceCode();
+    var tokensAndComments = sourceCode.tokensAndComments;
 
     var options = {
         before: context.options[0] ? !!context.options[0].before : false,
@@ -24,10 +25,6 @@ module.exports = function(context) {
     // Helpers
     //--------------------------------------------------------------------------
 
-    // the index of the last comment that was checked
-    var lastCommentIndex = 0;
-    var allComments;
-
     // list of comma tokens to ignore for the check of leading whitespace
     var commaTokensToIgnore = [];
 
@@ -41,39 +38,6 @@ module.exports = function(context) {
         return !!token && (token.type === "Punctuator") && (token.value === ",");
     }
 
-    /**
-     * 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
-     * through the file, once an index is passed a certain comment, we can
-     * go to the next comment to check that.
-     * @param {int} index The source index to check.
-     * @param {ASTNode[]} comments An array of comment nodes.
-     * @returns {boolean} True if the index is within a comment, false if not.
-     * @private
-     */
-    function isIndexInComment(index, comments) {
-
-        var comment;
-        lastCommentIndex = 0;
-
-        while (lastCommentIndex < comments.length) {
-
-            comment = comments[lastCommentIndex];
-
-            if (comment.range[0] <= index && index < comment.range[1]) {
-                return true;
-            } else if (index > comment.range[1]) {
-                lastCommentIndex++;
-            } else {
-                break;
-            }
-
-        }
-
-        return false;
-    }
-
-
     /**
      * Reports a spacing error with an appropriate message.
      * @param {ASTNode} node The binary expression node to report.
@@ -93,9 +57,6 @@ module.exports = function(context) {
                         return fixer.insertTextAfter(node, " ");
                     }
                 } else {
-                    /*
-                     * Comments handling
-                     */
                     var start, end;
                     var newText = "";
 
@@ -107,11 +68,6 @@ module.exports = function(context) {
                         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);
                 }
             },
@@ -137,6 +93,11 @@ module.exports = function(context) {
         ) {
             report(reportItem, "before", tokens.left);
         }
+
+        if (tokens.right && !options.after && tokens.right.type === "Line") {
+            return false;
+        }
+
         if (tokens.right && astUtils.isTokenOnSameLine(tokens.comma, tokens.right) &&
                 (options.after !== sourceCode.isSpaceBetweenTokens(tokens.comma, tokens.right))
         ) {
@@ -176,30 +137,28 @@ module.exports = function(context) {
     return {
         "Program:exit": function() {
 
-            var source = context.getSource(),
-                pattern = /,/g,
-                commaToken,
-                previousToken,
+            var previousToken,
                 nextToken;
 
-            allComments = context.getAllComments();
-            while (pattern.test(source)) {
-
-                // do not flag anything inside of comments
-                if (!isIndexInComment(pattern.lastIndex, allComments)) {
-                    commaToken = context.getTokenByRangeStart(pattern.lastIndex - 1);
-
-                    if (commaToken && commaToken.type !== "JSXText") {
-                        previousToken = context.getTokenBefore(commaToken);
-                        nextToken = context.getTokenAfter(commaToken);
-                        validateCommaItemSpacing({
-                            comma: commaToken,
-                            left: isComma(previousToken) || commaTokensToIgnore.indexOf(commaToken) > -1 ? null : previousToken,
-                            right: isComma(nextToken) ? null : nextToken
-                        }, commaToken);
-                    }
+            tokensAndComments.forEach(function(token, i) {
+
+                if (!isComma(token)) {
+                    return;
                 }
-            }
+
+                if (token && token.type === "JSXText") {
+                    return;
+                }
+
+                previousToken = tokensAndComments[i - 1];
+                nextToken = tokensAndComments[i + 1];
+
+                validateCommaItemSpacing({
+                    comma: token,
+                    left: isComma(previousToken) || commaTokensToIgnore.indexOf(token) > -1 ? null : previousToken,
+                    right: isComma(nextToken) ? null : nextToken
+                }, token);
+            });
         },
         "ArrayExpression": addNullElementsToIgnoreList,
         "ArrayPattern": addNullElementsToIgnoreList

package/lib/rules/consistent-this.js

@@ -53,39 +53,35 @@ module.exports = function(context) {
      */
     function ensureWasAssigned() {
         var scope = context.getScope();
+        var variable = scope.set.get(alias);
+        if (!variable) {
+            return;
+        }
+
+        if (variable.defs.some(function(def) {
+            return def.node.type === "VariableDeclarator" &&
+                def.node.init !== null;
+        })) {
+            return;
+        }
 
-        scope.variables.some(function(variable) {
-            var lookup;
-
-            if (variable.name === alias) {
-                if (variable.defs.some(function(def) {
-                    return def.node.type === "VariableDeclarator" &&
-                        def.node.init !== null;
-                })) {
-                    return true;
-                }
-
-                lookup = scope.type === "global" ? scope : variable;
-
-                // The alias has been declared and not assigned: check it was
-                // assigned later in the same scope.
-                if (!lookup.references.some(function(reference) {
-                    var write = reference.writeExpr;
-
-                    if (reference.from === scope &&
-                            write && write.type === "ThisExpression" &&
-                            write.parent.operator === "=") {
-                        return true;
-                    }
-                })) {
-                    variable.defs.map(function(def) {
-                        return def.node;
-                    }).forEach(reportBadAssignment);
-                }
+        var lookup = (variable.references.length === 0 && scope.type === "global") ? scope : variable;
 
+        // The alias has been declared and not assigned: check it was
+        // assigned later in the same scope.
+        if (!lookup.references.some(function(reference) {
+            var write = reference.writeExpr;
+
+            if (reference.from === scope &&
+                    write && write.type === "ThisExpression" &&
+                    write.parent.operator === "=") {
                 return true;
             }
-        });
+        })) {
+            variable.defs.map(function(def) {
+                return def.node;
+            }).forEach(reportBadAssignment);
+        }
     }
 
     return {

package/lib/rules/curly.js

@@ -51,6 +51,22 @@ module.exports = function(context) {
         return first.loc.start.line === last.loc.end.line;
     }
 
+    /**
+     * Gets the `else` keyword token of a given `IfStatement` node.
+     * @param {ASTNode} node - A `IfStatement` node to get.
+     * @returns {Token} The `else` keyword token.
+     */
+    function getElseKeyword(node) {
+        var sourceCode = context.getSourceCode();
+        var token = sourceCode.getTokenAfter(node.consequent);
+
+        while (token.type !== "Keyword" || token.value !== "else") {
+            token = sourceCode.getTokenAfter(token);
+        }
+
+        return token;
+    }
+
     /**
      * Checks a given IfStatement node requires braces of the consequent chunk.
      * This returns `true` when below:
@@ -89,11 +105,15 @@ module.exports = function(context) {
      * @private
      */
     function reportExpectedBraceError(node, name, suffix) {
-        context.report(node, "Expected { after '{{name}}'{{suffix}}.",
-            {
+        context.report({
+            node: node,
+            loc: (name !== "else" ? node : getElseKeyword(node)).loc.start,
+            message: "Expected { after '{{name}}'{{suffix}}.",
+            data: {
                 name: name,
                 suffix: (suffix ? " " + suffix : "")
-            });
+            }
+        });
     }
 
     /**
@@ -105,12 +125,15 @@ module.exports = function(context) {
      * @private
      */
     function reportUnnecessaryBraceError(node, name, suffix) {
-        context.report(node, "Unnecessary { after '{{name}}'{{suffix}}.",
-            {
+        context.report({
+            node: node,
+            loc: (name !== "else" ? node : getElseKeyword(node)).loc.start,
+            message: "Unnecessary { after '{{name}}'{{suffix}}.",
+            data: {
                 name: name,
                 suffix: (suffix ? " " + suffix : "")
             }
-        );
+        });
     }
 
     /**
@@ -224,9 +247,16 @@ module.exports = function(context) {
 
         "ForStatement": function(node) {
             prepareCheck(node, node.body, "for", "condition").check();
+        },
+
+        "ForInStatement": function(node) {
+            prepareCheck(node, node.body, "for-in").check();
+        },
+
+        "ForOfStatement": function(node) {
+            prepareCheck(node, node.body, "for-of").check();
         }
     };
-
 };
 
 module.exports.schema = {

package/lib/rules/eqeqeq.js

@@ -13,7 +13,11 @@
 
 module.exports = function(context) {
 
-    var sourceCode = context.getSourceCode();
+    var sourceCode = context.getSourceCode(),
+        replacements = {
+            "==": "===",
+            "!=": "!=="
+        };
 
     /**
      * Checks if an expression is a typeof expression
@@ -89,7 +93,18 @@ module.exports = function(context) {
                 message: "Expected '{{op}}=' and instead saw '{{op}}'.",
                 data: { op: node.operator },
                 fix: function(fixer) {
-                    return fixer.insertTextAfter(sourceCode.getTokenAfter(node.left), "=");
+                    var tokens = sourceCode.getTokensBetween(node.left, node.right),
+                        opToken,
+                        i;
+
+                    for (i = 0; i < tokens.length; ++i) {
+                        if (tokens[i].value === node.operator) {
+                            opToken = tokens[i];
+                            break;
+                        }
+                    }
+
+                    return fixer.replaceTextRange(opToken.range, replacements[node.operator]);
                 }
             });
 

package/lib/rules/id-length.js

@@ -25,12 +25,12 @@ module.exports = function(context) {
         }, {});
 
     var SUPPORTED_EXPRESSIONS = {
-        "MemberExpression": function(parent) {
+        "MemberExpression": properties && function(parent) {
             return !parent.computed && (
                 // regular property assignment
                 parent.parent.left === parent || (
                     // or the last identifier in an ObjectPattern destructuring
-                    parent.parent.type === "Property" && properties && parent.parent.value === parent &&
+                    parent.parent.type === "Property" && parent.parent.value === parent &&
                     parent.parent.parent.type === "ObjectPattern" && parent.parent.parent.parent.left === parent.parent.parent
                 )
             );

package/lib/rules/indent.js

@@ -75,6 +75,11 @@ module.exports = function(context) {
         }
     }
 
+    var indentPattern = {
+        normal: indentType === "space" ? /^ +/ : /^\t+/,
+        excludeCommas: indentType === "space" ? /^[ ,]+/ : /^[\t,]+/
+    };
+
     var caseIndentStore = {};
 
     /**
@@ -168,17 +173,9 @@ module.exports = function(context) {
     function getNodeIndent(node, byLastLine, excludeCommas) {
         var token = byLastLine ? context.getLastToken(node) : context.getFirstToken(node);
         var src = context.getSource(token, token.loc.start.column);
-
-        var skip = excludeCommas ? "," : "";
-
-        var regExp;
-        if (indentType === "space") {
-            regExp = new RegExp("^[ " + skip + "]+");
-        } else {
-            regExp = new RegExp("^[\t" + skip + "]+");
-        }
-
+        var regExp = excludeCommas ? indentPattern.excludeCommas : indentPattern.normal;
         var indent = regExp.exec(src);
+
         return indent ? indent[0].length : 0;
     }
 

package/lib/rules/lines-around-comment.js

@@ -7,6 +7,16 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var assign = require("object-assign");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
 /**
  * Return an array with with any line numbers that are empty.
  * @param {Array} lines An array of each line of the file.
@@ -57,7 +67,7 @@ function contains(val, array) {
 
 module.exports = function(context) {
 
-    var options = context.options[0] || {};
+    var options = context.options[0] ? assign({}, context.options[0]) : {};
     options.beforeLineComment = options.beforeLineComment || false;
     options.afterLineComment = options.afterLineComment || false;
     options.beforeBlockComment = typeof options.beforeBlockComment !== "undefined" ? options.beforeBlockComment : true;
@@ -65,26 +75,34 @@ module.exports = function(context) {
     options.allowBlockStart = options.allowBlockStart || false;
     options.allowBlockEnd = options.allowBlockEnd || false;
 
+    var sourceCode = context.getSourceCode();
     /**
-     * Returns whether or not comments are not on lines starting with or ending with code
+     * Returns whether or not comments are on lines starting with or ending with code
      * @param {ASTNode} node The comment node to check.
      * @returns {boolean} True if the comment is not alone.
      */
     function codeAroundComment(node) {
+        var token;
 
-        var lines = context.getSourceLines();
+        token = node;
+        do {
+            token = sourceCode.getTokenOrCommentBefore(token);
+        } while (token && (token.type === "Block" || token.type === "Line"));
 
-        // Get the whole line and cut it off at the start of the comment
-        var startLine = lines[node.loc.start.line - 1];
-        var endLine = lines[node.loc.end.line - 1];
+        if (token && token.loc.end.line === node.loc.start.line) {
+            return true;
+        }
 
-        var preamble = startLine.slice(0, node.loc.start.column).trim();
+        token = node;
+        do {
+            token = sourceCode.getTokenOrCommentAfter(token);
+        } while (token && (token.type === "Block" || token.type === "Line"));
 
-        // Also check after the comment
-        var postamble = endLine.slice(node.loc.end.column).trim();
+        if (token && token.loc.start.line === node.loc.end.line) {
+            return true;
+        }
 
-        // Should be false if there was only whitespace around the comment
-        return !!(preamble || postamble);
+        return false;
     }
 
     /**
@@ -95,7 +113,9 @@ module.exports = function(context) {
      * @returns {boolean} True if the comment is inside nodeType.
      */
     function isCommentInsideNodeType(node, parent, nodeType) {
-        return parent.type === nodeType || (parent.body && parent.body.type === nodeType);
+        return parent.type === nodeType ||
+            (parent.body && parent.body.type === nodeType) ||
+            (parent.consequent && parent.consequent.type === nodeType);
     }
 
     /**

package/lib/rules/new-cap.js

@@ -7,6 +7,16 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var assign = require("object-assign");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
 var CAPS_ALLOWED = [
     "Array",
     "Boolean",
@@ -67,7 +77,7 @@ function calculateCapIsNewExceptions(config) {
 
 module.exports = function(context) {
 
-    var config = context.options[0] || {};
+    var config = context.options[0] ? assign({}, context.options[0]) : {};
     config.newIsCap = config.newIsCap !== false;
     config.capIsNew = config.capIsNew !== false;
     var skipProperties = config.properties === false;

package/lib/rules/no-alert.js

@@ -69,9 +69,8 @@ function findReference(scope, node) {
  * @returns {boolean} Whether or not the name is shadowed globally.
  */
 function isGloballyShadowed(globalScope, identifierName) {
-    return globalScope.variables.some(function(variable) {
-        return variable.name === identifierName && variable.defs.length > 0;
-    });
+    var variable = globalScope.set.get(identifierName);
+    return Boolean(variable && variable.defs.length > 0);
 }
 
 /**

package/lib/rules/no-catch-shadow.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -22,19 +28,7 @@ module.exports = function(context) {
      * @returns {boolean} True is its been shadowed
      */
     function paramIsShadowing(scope, name) {
-        var found = scope.variables.some(function(variable) {
-            return variable.name === name;
-        });
-
-        if (found) {
-            return true;
-        }
-
-        if (scope.upper) {
-            return paramIsShadowing(scope.upper, name);
-        }
-
-        return false;
+        return astUtils.getVariableByName(scope, name) !== null;
     }
 
     //--------------------------------------------------------------------------

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

@@ -68,8 +68,7 @@ module.exports = function(context) {
 
                 // verify the object being added to is a native prototype
                 subject = node.arguments[0];
-                object = subject.object;
-
+                object = subject && subject.object;
                 if (object &&
                     object.type === "Identifier" &&
                     (modifiedBuiltins.indexOf(object.name) > -1) &&

package/lib/rules/no-fallthrough.js

@@ -48,8 +48,7 @@ module.exports = function(context) {
 
                 // check for comment
                 if (!comment || !FALLTHROUGH_COMMENT.test(comment.value)) {
-
-                    context.report(switchData.lastCase,
+                    context.report(node,
                         "Expected a \"break\" statement before \"{{code}}\".",
                         { code: node.test ? "case" : "default" });
                 }

package/lib/rules/no-implicit-coercion.js

@@ -113,6 +113,15 @@ function isConcatWithEmptyString(node) {
     );
 }
 
+/**
+ * Checks whether or not a node is appended with an empty string.
+ * @param {ASTNode} node - An AssignmentExpression node to check.
+ * @returns {boolean} Whether or not the node is appended with an empty string.
+ */
+function isAppendEmptyString(node) {
+    return node.operator === "+=" && node.right.type === "Literal" && node.right.value === "";
+}
+
 /**
  * Gets a node that is the left or right operand of a node, is not the specified literal.
  * @param {ASTNode} node - A BinaryExpression node to get.
@@ -178,6 +187,16 @@ module.exports = function(context) {
                     "use `String({{code}})` instead.",
                     {code: context.getSource(getOtherOperand(node, ""))});
             }
+        },
+
+        "AssignmentExpression": function(node) {
+            // foo += ""
+            if (options.string && isAppendEmptyString(node)) {
+                context.report(
+                    node,
+                    "use `{{code}} = String({{code}})` instead.",
+                    {code: context.getSource(getOtherOperand(node, ""))});
+            }
         }
     };
 };