eslint 0.5.0 → 0.6.2

package/lib/rules/block-scoped-var.js

@@ -46,7 +46,16 @@ module.exports = function(context) {
      * @returns {Boolean} true when the identifier is in property position.
      */
     function isProperty(id, parent) {
-        return id === parent.property && parent.type === "MemberExpression" && !parent.computed;
+        switch (parent.type) {
+            case "MemberExpression":
+                return id === parent.property && !parent.computed;
+
+            case "Property":
+                return id === parent.key;
+
+            default:
+                return false;
+        }
     }
 
     /**
@@ -84,6 +93,13 @@ module.exports = function(context) {
             return id.name;
         }));
         declare(node.id ? [node.id.name] : []);
+        declare(["arguments"]);
+    }
+
+    function variableDeclarationHandler(node) {
+        declare(node.declarations.map(function(decl) {
+            return decl.id.name;
+        }));
     }
 
     return {
@@ -98,9 +114,7 @@ module.exports = function(context) {
             pushScope();
             statements.forEach(function(stmt) {
                 if (stmt.type === "VariableDeclaration") {
-                    declare(stmt.declarations.map(function(decl) {
-                        return decl.id.name;
-                    }));
+                    variableDeclarationHandler(stmt);
                 } else if (stmt.type === "FunctionDeclaration") {
                     declare([stmt.id.name]);
                 }
@@ -113,9 +127,29 @@ module.exports = function(context) {
             pushScope();
             declare([node.param.name]);
         },
+        "CatchClause:exit": popScope,
 
         "FunctionDeclaration": functionHandler,
+        "FunctionDeclaration:exit": popScope,
+
         "FunctionExpression": functionHandler,
+        "FunctionExpression:exit": popScope,
+
+        "ForStatement": function(node) {
+            pushScope();
+            if (node.init && node.init.type === "VariableDeclaration") {
+                variableDeclarationHandler(node.init);
+            }
+        },
+        "ForStatement:exit": popScope,
+
+        "ForInStatement": function(node) {
+            pushScope();
+            if (node.left.type === "VariableDeclaration") {
+                variableDeclarationHandler(node.left);
+            }
+        },
+        "ForInStatement:exit": popScope,
 
         "Identifier": function(node) {
             var ancestor = context.getAncestors().pop();

package/lib/rules/brace-style.js

@@ -13,6 +13,7 @@ module.exports = function(context) {
     var style = context.options[0] || "1tbs";
 
     var OPEN_MESSAGE = "Opening curly brace does not appear on the same line as controlling statement.",
+        BODY_MESSAGE = "Statement inside of curly braces should be on next line.",
         CLOSE_MESSAGE = "Closing curly brace does not appear on the same line as the subsequent block.",
         CLOSE_MESSAGE_STROUSTRUP = "Closing curly brace appears on the same line as the subsequent block.";
 
@@ -33,11 +34,14 @@ module.exports = function(context) {
             [].forEach.call(blockProperties, function(blockProp) {
                 var block = node[blockProp], previousToken, curlyToken;
                 block = node[blockProp];
-                if(block && block.type === "BlockStatement") {
+                if (block && block.type === "BlockStatement") {
                     previousToken = context.getTokenBefore(block);
                     curlyToken = context.getFirstToken(block);
+
                     if (previousToken.loc.start.line !== curlyToken.loc.start.line) {
                         context.report(node, OPEN_MESSAGE);
+                    } else if (block.body.length && curlyToken.loc.start.line === block.body[0].loc.start.line) {
+                        context.report(block.body[0], BODY_MESSAGE);
                     }
                 }
             });
@@ -123,7 +127,7 @@ module.exports = function(context) {
      */
     function checkSwitchStatement(node) {
         var tokens;
-        if(node.cases && node.cases.length) {
+        if (node.cases && node.cases.length) {
             tokens = context.getTokensBefore(node.cases[0], 2);
             if (tokens[0].loc.start.line !== tokens[1].loc.start.line) {
                 context.report(node, OPEN_MESSAGE);

package/lib/rules/default-case.js

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview require default case in switch statements
+ * @author Aliaksei Shytkin
+ */
+"use strict";
+
+var COMMENT_VALUE = "no default";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Shortcut to get last element of array
+     * @param  {*[]} collection Array
+     * @returns {*} Last element
+     */
+    function last(collection) {
+        return collection[collection.length - 1];
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "SwitchStatement": function(node) {
+
+            if (!node.cases.length) {
+                // skip check of empty switch because there is no easy way
+                // to extract comments inside it now
+                return;
+            }
+
+            var hasDefault = node.cases.some(function(v) {
+                return v.test === null;
+            });
+
+            if (!hasDefault) {
+
+                var comment;
+                var comments;
+
+                var lastCase = last(node.cases);
+                comments = context.getComments(lastCase).trailing;
+
+                if (comments.length) {
+                    comment = last(comments);
+                }
+
+                if (!comment || comment.value.trim() !== COMMENT_VALUE) {
+                    context.report(node, "Expected a default case.");
+                }
+            }
+        }
+    };
+};

package/lib/rules/eqeqeq.js

@@ -36,6 +36,10 @@ module.exports = function(context) {
                 return;
             }
 
+            if (context.options[0] === "allow-null" && isNullCheck(node)) {
+                return;
+            }
+
             if (operator === "==") {
                 context.report(node, "Expected '===' and instead saw '=='.");
             } else if (operator === "!=") {

package/lib/rules/new-cap.js

@@ -22,7 +22,7 @@ module.exports = function(context) {
                 constructorName = node.callee.name;
             }
 
-            if (constructorName && constructorName.charAt(0) === constructorName.charAt(0).toLowerCase()) {
+            if (constructorName && constructorName.charAt(0) !== constructorName.charAt(0).toUpperCase()) {
                 context.report(node, "A constructor name should start with an uppercase letter.");
             }
         }

package/lib/rules/no-comma-dangle.js

@@ -22,7 +22,7 @@ module.exports = function(context) {
             lastItem = items[items.length - 1];
         // The last token in an object/array literal will always be a closing
         // curly, so we check the second to last token for a comma.
-        if(secondToLastToken.value === "," && items.length && lastItem) {
+        if (secondToLastToken.value === "," && items.length && lastItem) {
             context.report(lastItem, secondToLastToken.loc.start, "Trailing comma.");
         }
     }

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

@@ -23,7 +23,7 @@ module.exports = function(context) {
      * @private
      */
     function isConstant(node) {
-        switch(node.type) {
+        switch (node.type) {
         case "Literal":
         case "FunctionExpression":
         case "ObjectExpression":
@@ -38,6 +38,7 @@ module.exports = function(context) {
             return isConstant(node.right);
         case "SequenceExpression":
             return isConstant(node.expressions[node.expressions.length - 1]);
+        // no default
         }
         return false;
     }

package/lib/rules/no-delete-var.js

@@ -15,7 +15,7 @@ module.exports = function(context) {
 
         "UnaryExpression": function(node) {
             if (node.operator === "delete" && node.argument.type === "Identifier") {
-                context.report(node, "Variables should not be deleted​.");
+                context.report(node, "Variables should not be deleted.");
             }
         }
     };

package/lib/rules/no-else-return.js

@@ -17,7 +17,7 @@ module.exports = function(context) {
 
     function checkForReturnStatement(node, alternate) {
         if (node.type === "ReturnStatement") {
-            context.report(alternate, "Unexpected 'else' after 'return'​.");
+            context.report(alternate, "Unexpected 'else' after 'return'.");
         }
     }
 

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

@@ -27,13 +27,17 @@ module.exports = function(context) {
         "AssignmentExpression": function(node) {
             var lhs = node.left, affectsProto;
 
-            if (lhs.type !== "MemberExpression" || lhs.object.type !== "MemberExpression") { return; }
+            if (lhs.type !== "MemberExpression" || lhs.object.type !== "MemberExpression") {
+                return;
+            }
 
             affectsProto = lhs.object.computed ?
                 lhs.object.property.type === "Literal" && lhs.object.property.value === "prototype" :
                 lhs.object.property.name === "prototype";
 
-            if (!affectsProto) { return; }
+            if (!affectsProto) {
+                return;
+            }
 
             BUILTINS.forEach(function(builtin) {
                 if (lhs.object.object.name === builtin) {

package/lib/rules/no-extra-parens.js

@@ -30,7 +30,7 @@ module.exports = function(context) {
 
     function precedence(node) {
 
-        switch(node.type) {
+        switch (node.type) {
             case "SequenceExpression":
                 return 0;
 
@@ -41,16 +41,17 @@ module.exports = function(context) {
                 return 3;
 
             case "LogicalExpression":
-                switch(node.operator) {
+                switch (node.operator) {
                     case "||":
                         return 4;
                     case "&&":
                         return 5;
+                    // no default
                 }
 
                 /* falls through */
             case "BinaryExpression":
-                switch(node.operator) {
+                switch (node.operator) {
                     case "|":
                         return 6;
                     case "^":
@@ -80,6 +81,7 @@ module.exports = function(context) {
                     case "/":
                     case "%":
                         return 13;
+                    // no default
                 }
                 /* falls through */
             case "UnaryExpression":
@@ -87,9 +89,14 @@ module.exports = function(context) {
             case "UpdateExpression":
                 return 15;
             case "CallExpression":
+                // IIFE is allowed to have parens in any position (#655)
+                if (node.callee.type === "FunctionExpression") {
+                    return -1;
+                }
                 return 16;
             case "NewExpression":
                 return 17;
+            // no default
         }
         return 18;
     }
@@ -99,22 +106,22 @@ module.exports = function(context) {
     }
 
     function dryUnaryUpdate(node) {
-        if(isParenthesised(node.argument) && precedence(node.argument) >= precedence(node)) {
+        if (isParenthesised(node.argument) && precedence(node.argument) >= precedence(node)) {
             report(node.argument);
         }
     }
 
     function dryCallNew(node) {
-        if(isParenthesised(node.callee) && precedence(node.callee) >= precedence(node)) {
+        if (isParenthesised(node.callee) && precedence(node.callee) >= precedence(node)) {
             report(node.callee);
         }
-        if(node.arguments.length === 1) {
-            if(isParenthesisedTwice(node.arguments[0]) && precedence(node.arguments[0]) >= precedence({type: "AssignmentExpression"})) {
+        if (node.arguments.length === 1) {
+            if (isParenthesisedTwice(node.arguments[0]) && precedence(node.arguments[0]) >= precedence({type: "AssignmentExpression"})) {
                 report(node.arguments[0]);
             }
         } else {
             [].forEach.call(node.arguments, function(arg){
-                if(isParenthesised(arg) && precedence(arg) >= precedence({type: "AssignmentExpression"})) {
+                if (isParenthesised(arg) && precedence(arg) >= precedence({type: "AssignmentExpression"})) {
                     report(arg);
                 }
             });
@@ -123,10 +130,10 @@ module.exports = function(context) {
 
     function dryBinaryLogical(node) {
         var prec = precedence(node);
-        if(isParenthesised(node.left) && precedence(node.left) >= prec) {
+        if (isParenthesised(node.left) && precedence(node.left) >= prec) {
             report(node.left);
         }
-        if(isParenthesised(node.right) && precedence(node.right) > prec) {
+        if (isParenthesised(node.right) && precedence(node.right) > prec) {
             report(node.right);
         }
     }
@@ -134,55 +141,69 @@ module.exports = function(context) {
     return {
         "ArrayExpression": function(node) {
             [].forEach.call(node.elements, function(e) {
-                if(e && isParenthesised(e) && precedence(e) >= precedence({type: "AssignmentExpression"})) {
+                if (e && isParenthesised(e) && precedence(e) >= precedence({type: "AssignmentExpression"})) {
                     report(e);
                 }
             });
         },
         "AssignmentExpression": function(node) {
-            if(isParenthesised(node.right) && precedence(node.right) >= precedence(node)) {
+            if (isParenthesised(node.right) && precedence(node.right) >= precedence(node)) {
                 report(node.right);
             }
         },
         "BinaryExpression": dryBinaryLogical,
         "CallExpression": dryCallNew,
         "ConditionalExpression": function(node) {
-            if(isParenthesised(node.test) && precedence(node.test) >= precedence({type: "LogicalExpression", operator: "||"})) {
+            if (isParenthesised(node.test) && precedence(node.test) >= precedence({type: "LogicalExpression", operator: "||"})) {
                 report(node.test);
             }
-            if(isParenthesised(node.consequent) && precedence(node.consequent) >= precedence({type: "AssignmentExpression"})) {
+            if (isParenthesised(node.consequent) && precedence(node.consequent) >= precedence({type: "AssignmentExpression"})) {
                 report(node.consequent);
             }
-            if(isParenthesised(node.alternate) && precedence(node.alternate) >= precedence({type: "AssignmentExpression"})) {
+            if (isParenthesised(node.alternate) && precedence(node.alternate) >= precedence({type: "AssignmentExpression"})) {
                 report(node.alternate);
             }
         },
         "DoWhileStatement": function(node) {
-            if(isParenthesisedTwice(node.test)) { report(node.test); }
+            if (isParenthesisedTwice(node.test)) {
+                report(node.test);
+            }
         },
         "ExpressionStatement": function(node) {
             var firstToken;
-            if(isParenthesised(node.expression)) {
+            if (isParenthesised(node.expression)) {
                 firstToken = context.getFirstToken(node.expression);
-                if(firstToken.value !== "function" && firstToken.value !== "{") {
+                if (firstToken.value !== "function" && firstToken.value !== "{") {
                     report(node.expression);
                 }
             }
         },
         "ForInStatement": function(node) {
-            if(isParenthesised(node.right)) { report(node.right); }
+            if (isParenthesised(node.right)) {
+                report(node.right);
+            }
         },
         "ForStatement": function(node) {
-            if(node.init && isParenthesised(node.init)) { report(node.init); }
-            if(node.test && isParenthesised(node.test)) { report(node.test); }
-            if(node.update && isParenthesised(node.update)) { report(node.update); }
+            if (node.init && isParenthesised(node.init)) {
+                report(node.init);
+            }
+
+            if (node.test && isParenthesised(node.test)) {
+                report(node.test);
+            }
+
+            if (node.update && isParenthesised(node.update)) {
+                report(node.update);
+            }
         },
         "IfStatement": function(node) {
-            if(isParenthesisedTwice(node.test)) { report(node.test); }
+            if (isParenthesisedTwice(node.test)) {
+                report(node.test);
+            }
         },
         "LogicalExpression": dryBinaryLogical,
         "MemberExpression": function(node) {
-            if(
+            if (
                 isParenthesised(node.object) &&
                 precedence(node.object) >= precedence(node) &&
                 (
@@ -201,40 +222,54 @@ module.exports = function(context) {
         "ObjectExpression": function(node) {
             [].forEach.call(node.properties, function(e) {
                 var v = e.value;
-                if(v && isParenthesised(v) && precedence(v) >= precedence({type: "AssignmentExpression"})) {
+                if (v && isParenthesised(v) && precedence(v) >= precedence({type: "AssignmentExpression"})) {
                     report(v);
                 }
             });
         },
         "ReturnStatement": function(node) {
-            if(node.argument && isParenthesised(node.argument)) { report(node.argument); }
+            if (node.argument && isParenthesised(node.argument)) {
+                report(node.argument);
+            }
         },
         "SequenceExpression": function(node) {
             [].forEach.call(node.expressions, function(e) {
-                if(isParenthesised(e)) { report(e); }
+                if (isParenthesised(e) && precedence(e) >= precedence(node)) {
+                    report(e);
+                }
             });
         },
         "SwitchCase": function(node) {
-            if(node.test && isParenthesised(node.test)) { report(node.test); }
+            if (node.test && isParenthesised(node.test)) {
+                report(node.test);
+            }
         },
         "SwitchStatement": function(node) {
-            if(isParenthesisedTwice(node.discriminant)) { report(node.discriminant); }
+            if (isParenthesisedTwice(node.discriminant)) {
+                report(node.discriminant);
+            }
         },
         "ThrowStatement": function(node) {
-            if(isParenthesised(node.argument)) { report(node.argument); }
+            if (isParenthesised(node.argument)) {
+                report(node.argument);
+            }
         },
         "UnaryExpression": dryUnaryUpdate,
         "UpdateExpression": dryUnaryUpdate,
         "VariableDeclarator": function(node) {
-            if(node.init && isParenthesised(node.init) && precedence(node.init) >= precedence({type: "AssignmentExpression"})) {
+            if (node.init && isParenthesised(node.init) && precedence(node.init) >= precedence({type: "AssignmentExpression"})) {
                 report(node.init);
             }
         },
         "WhileStatement": function(node) {
-            if(isParenthesisedTwice(node.test)) { report(node.test); }
+            if (isParenthesisedTwice(node.test)) {
+                report(node.test);
+            }
         },
         "WithStatement": function(node) {
-            if(isParenthesisedTwice(node.object)) { report(node.object); }
+            if (isParenthesisedTwice(node.object)) {
+                report(node.object);
+            }
         }
     };
 

package/lib/rules/no-extra-strict.js

@@ -37,7 +37,7 @@ module.exports = function(context) {
         var useStrictDirectives, scope;
         useStrictDirectives = directives(node).filter(isStrict);
 
-        switch(useStrictDirectives.length) {
+        switch (useStrictDirectives.length) {
             case 0:
                 break;
 

package/lib/rules/no-fallthrough.js

@@ -25,6 +25,14 @@ module.exports = function(context) {
                 comments,
                 comment;
 
+            /*
+             * Some developers wrap case bodies in blocks, so if there is just one
+             * node and it's a block statement, check inside.
+             */
+            if (consequent.length === 1 && consequent[0].type === "BlockStatement") {
+                consequent = consequent[0];
+            }
+
             // checking on previous case
             if (!switchData.lastCaseClosed) {
 

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

@@ -0,0 +1,70 @@
+/**
+ * @fileoverview Rule to enforce declarations in program or function body root.
+ * @author Brandon Mills
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    "use strict";
+
+    /**
+     * Find the nearest Program or Function ancestor node.
+     * @returns {Object} Ancestor's type and distance from node.
+     */
+    function nearestBody() {
+        var ancestors = context.getAncestors(),
+            ancestor = ancestors.pop(),
+            generation = 1;
+
+        while (ancestor && ["Program", "FunctionDeclaration",
+                "FunctionExpression"].indexOf(ancestor.type) < 0) {
+            generation += 1;
+            ancestor = ancestors.pop();
+        }
+
+        return {
+            // Type of containing ancestor
+            type: ancestor.type,
+            // Separation between ancestor and node
+            distance: generation
+        };
+    }
+
+    /**
+     * Ensure that a given node is at a program or function body's root.
+     * @param {ASTNode} node Declaration node to check.
+     * @returns {void}
+     */
+    function check(node) {
+        var body = nearestBody(node),
+            valid = ((body.type === "Program" && body.distance === 1) ||
+                body.distance === 2);
+
+        if (!valid) {
+            context.report(node, "Move {{type}} declaration to {{body}} root.",
+                {
+                    type: (node.type === "FunctionDeclaration" ?
+                        "function" : "variable"),
+                    body: (body.type === "Program" ?
+                        "program" : "function body")
+                }
+            );
+        }
+    }
+
+    return {
+
+        "FunctionDeclaration": check,
+        "VariableDeclaration": function(node) {
+            if (context.options[0] === "both") {
+                check(node);
+            }
+        }
+
+    };
+
+};

package/lib/rules/no-invalid-regexp.js

@@ -15,9 +15,9 @@ module.exports = function(context) {
     }
 
     function check(node) {
-        if(node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(node.arguments[0])) {
+        if (node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(node.arguments[0])) {
             try {
-                if(isString(node.arguments[1])) {
+                if (isString(node.arguments[1])) {
                     void new RegExp(node.arguments[0].value, node.arguments[1].value);
                 } else {
                     void new RegExp(node.arguments[0].value);

package/lib/rules/no-lonely-if.js

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Rule to disallow if as the only statmenet in an else block
+ * @author Brandon Mills
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+        "IfStatement": function(node) {
+            var ancestors = context.getAncestors(),
+                parent = ancestors.pop(),
+                grandparent = ancestors.pop();
+
+            if (parent && parent.type === "BlockStatement" &&
+                    parent.body.length === 1 && grandparent &&
+                    grandparent.type === "IfStatement" &&
+                    parent === grandparent.alternate) {
+                context.report(node, "Unexpected if as the only statement in an else block.");
+            }
+        }
+    };
+
+};

package/lib/rules/no-mixed-requires.js

@@ -127,7 +127,7 @@ module.exports = function(context) {
         var found = {};
 
         declarations.forEach(function (declaration) {
-            if(getDeclarationType(declaration.init) === DECL_REQUIRE) {
+            if (getDeclarationType(declaration.init) === DECL_REQUIRE) {
                 found[inferModuleType(declaration.init)] = true;
             }
         });