eslint 1.7.0 → 1.8.0

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,8 +338,9 @@ module.exports = function(context) {
                     indent = getNodeIndent(calleeParent);
                 }
             } else {
-                if (isCallArgsMultiline(calleeParent) &&
-                    calleeParent.callee.loc.start.line === calleeParent.callee.loc.end.line) {
+                if (isArgBeforeCalleeNodeMultiline(calleeNode) &&
+                    calleeParent.callee.loc.start.line === calleeParent.callee.loc.end.line &&
+                    !isNodeFirstInLine(calleeNode)) {
                     indent = getNodeIndent(calleeParent);
                 }
             }
@@ -434,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/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-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,9 +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"];
 
-            if (!isNumber(node) || shouldIgnoreNumber(node.value)) {
+            if (!isNumber(node)) {
+                return;
+            }
+
+            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;
             }
 
@@ -79,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.");
                 }
             });
         }

package/lib/rules/no-multiple-empty-lines.js

@@ -13,13 +13,15 @@
 module.exports = function(context) {
 
     // Use options.max or 2 as default
-    var numLines = 2;
+    var max = 2,
+        maxEOF;
 
     // store lines that appear empty but really aren't
     var notEmpty = [];
 
     if (context.options.length) {
-        numLines = context.options[0].max;
+        max = context.options[0].max;
+        maxEOF = context.options[0].maxEOF;
     }
 
     //--------------------------------------------------------------------------
@@ -45,17 +47,28 @@ module.exports = function(context) {
                 location,
                 trimmedLines = lines.map(function(str) {
                     return str.trim();
-                });
+                }),
+                firstOfEndingBlankLines;
 
             // add the notEmpty lines in there with a placeholder
             notEmpty.forEach(function(x, i) {
                 trimmedLines[i] = x;
             });
 
-            // swallow the final newline, as some editors add it automatically
-            // and we don't want it to cause an issue
-            if (trimmedLines[trimmedLines.length - 1] === "") {
-                trimmedLines = trimmedLines.slice(0, -1);
+            if (typeof maxEOF === "undefined") {
+                // swallow the final newline, as some editors add it
+                // automatically and we don't want it to cause an issue
+                if (trimmedLines[trimmedLines.length - 1] === "") {
+                    trimmedLines = trimmedLines.slice(0, -1);
+                }
+                firstOfEndingBlankLines = trimmedLines.length;
+            } else {
+                // save the number of the first of the last blank lines
+                firstOfEndingBlankLines = trimmedLines.length;
+                while (trimmedLines[firstOfEndingBlankLines - 1] === ""
+                        && firstOfEndingBlankLines > 0) {
+                    firstOfEndingBlankLines--;
+                }
             }
 
             // Aggregate and count blank lines
@@ -67,12 +80,22 @@ module.exports = function(context) {
                 if (lastLocation === currentLocation - 1) {
                     blankCounter++;
                 } else {
-                    if (blankCounter >= numLines) {
-                        location = {
-                            line: lastLocation + 1,
-                            column: lines[lastLocation].length
-                        };
-                        context.report(node, location, "Multiple blank lines not allowed.");
+                    location = {
+                        line: lastLocation + 1,
+                        column: 1
+                    };
+                    if (lastLocation < firstOfEndingBlankLines) {
+                        // within the file, not at the end
+                        if (blankCounter >= max) {
+                            context.report(node, location,
+                                    "Multiple blank lines not allowed.");
+                        }
+                    } else {
+                        // inside the last blank lines
+                        if (blankCounter >= maxEOF) {
+                            context.report(node, location,
+                                    "Too many blank lines at the end of file.");
+                        }
                     }
 
                     // Finally, reset the blank counter
@@ -90,6 +113,9 @@ module.exports.schema = [
         "properties": {
             "max": {
                 "type": "integer"
+            },
+            "maxEOF": {
+                "type": "integer"
             }
         },
         "required": ["max"],

package/lib/rules/no-plusplus.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Rule to flag use of unary increment and decrement operators.
  * @author Ian Christian Myers
+ * @author Brody McKee (github.com/mrmckeb)
  */
 
 "use strict";
@@ -11,9 +12,19 @@
 
 module.exports = function(context) {
 
+    var config = context.options[0],
+        allowInForAfterthought = false;
+
+    if (typeof config === "object") {
+        allowInForAfterthought = config.allowForLoopAfterthoughts === true;
+    }
+
     return {
 
         "UpdateExpression": function(node) {
+            if (allowInForAfterthought && node.parent.type === "ForStatement") {
+                return;
+            }
             context.report(node, "Unary operator '" + node.operator + "' used.");
         }
 
@@ -21,4 +32,14 @@ module.exports = function(context) {
 
 };
 
-module.exports.schema = [];
+module.exports.schema = [
+    {
+        "type": "object",
+        "properties": {
+            "allowForLoopAfterthoughts": {
+                "type": "boolean"
+            }
+        },
+        "additionalProperties": false
+    }
+];

package/lib/rules/no-shadow.js

@@ -14,9 +14,20 @@ module.exports = function(context) {
 
     var options = {
         builtinGlobals: Boolean(context.options[0] && context.options[0].builtinGlobals),
-        hoist: (context.options[0] && context.options[0].hoist) || "functions"
+        hoist: (context.options[0] && context.options[0].hoist) || "functions",
+        allow: (context.options[0] && context.options[0].allow) || []
     };
 
+    /**
+     * Check if variable name is allowed.
+     *
+     * @param  {ASTNode} variable The variable to check.
+     * @returns {boolean} Whether or not the variable name is allowed.
+     */
+    function isAllowed(variable) {
+        return options.allow.indexOf(variable.name) !== -1;
+    }
+
     /**
      * Checks if a variable of the class name in the class scope of ClassDeclaration.
      *
@@ -142,7 +153,8 @@ module.exports = function(context) {
                 // Skip "arguments".
                 variable.identifiers.length > 0 &&
                 // Skip variables of a class name in the class scope of ClassDeclaration.
-                !isDuplicatedClassNameVariable(variable)
+                !isDuplicatedClassNameVariable(variable) &&
+                !isAllowed(variable)
             );
         });
 
@@ -175,7 +187,13 @@ module.exports.schema = [
         "type": "object",
         "properties": {
             "builtinGlobals": {"type": "boolean"},
-            "hoist": {"enum": ["all", "functions", "never"]}
+            "hoist": {"enum": ["all", "functions", "never"]},
+            "allow": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                }
+            }
         },
         "additionalProperties": false
     }