eslint 0.6.1 → 0.6.2

package/lib/config.js

@@ -92,12 +92,18 @@ function loadConfig(filePath) {
  * @returns {Object} the local config object (empty object if there is no local config)
  */
 function getLocalConfig(helper, directory) {
-    var localConfigFile = helper.findLocalConfigFile(directory),
-        config = {};
+    var localConfigFile,
+        config = {},
+        parentDirectory;
 
-    /* istanbul ignore else Too complicated to create unittest*/
-    if (localConfigFile) {
-        config = loadConfig(localConfigFile);
+    while ((localConfigFile = helper.findLocalConfigFile(directory))) {
+        config = util.mergeConfigs(loadConfig(localConfigFile), config);
+
+        parentDirectory = path.dirname(directory);
+        if (directory === parentDirectory) {
+            break;
+        }
+        directory = parentDirectory;
     }
 
     return config;

package/lib/eslint.js

@@ -354,7 +354,9 @@ module.exports = (function() {
         currentScopes = null,
         currentFilename = null,
         controller = null,
-        reportingConfig = [];
+        reportingConfig = [],
+        commentLocsEnter = [],
+        commentLocsExit = [];
 
     /**
      * Parses text into an AST. Moved out here because the try-catch prevents
@@ -396,6 +398,46 @@ module.exports = (function() {
         }
     }
 
+    /**
+     * Check collection of comments to prevent double event for comment as
+     * leading and trailing, then emit event if passing
+     * @param {ASTNode[]} comments Collection of comment nodes
+     * @param {Object[]} locs List of locations of previous comment nodes
+     * @param {string} eventName Event name postfix
+     * @returns {void}
+     */
+    function emitComments(comments, locs, eventName) {
+
+        if (comments.length) {
+            comments.forEach(function(node) {
+                if (locs.indexOf(node.loc) >= 0) {
+                    locs.splice(locs.indexOf(node.loc), 1);
+                } else {
+                    locs.push(node.loc);
+                    api.emit(node.type + eventName, node);
+                }
+            });
+        }
+    }
+
+    /**
+     * Shortcut to check and emit enter of comment nodes
+     * @param {ASTNode[]} comments Collection of comment nodes
+     * @returns {void}
+     */
+    function emitCommentsEnter(comments) {
+        emitComments(comments, commentLocsEnter, "Comment");
+    }
+
+    /**
+     * Shortcut to check and emit exit of comment nodes
+     * @param {ASTNode[]} comments Collection of comment nodes
+     * @returns {void}
+     */
+    function emitCommentsExit(comments) {
+        emitComments(comments, commentLocsExit, "Comment:exit");
+    }
+
     // set unlimited listeners (see https://github.com/eslint/eslint/issues/524)
     api.setMaxListeners(0);
 
@@ -412,6 +454,8 @@ module.exports = (function() {
         currentScopes = null;
         controller = null;
         reportingConfig = [];
+        commentLocsEnter = [];
+        commentLocsExit = [];
     };
 
     /**
@@ -512,46 +556,20 @@ module.exports = (function() {
             controller.traverse(ast, {
                 enter: function(node, parent) {
 
-                    var comments = api.getComments(node),
-                        leadingComments = comments.leading,
-                        trailingComments = comments.trailing;
-
-                    if (leadingComments.length) {
-                        leadingComments.forEach(function(node) {
-                            api.emit(node.type + "Comment", node);
-                        });
-                    }
+                    var comments = api.getComments(node);
 
+                    emitCommentsEnter(comments.leading);
                     node.parent = parent;
-
                     api.emit(node.type, node);
-
-                    if (trailingComments.length) {
-                        trailingComments.forEach(function(node) {
-                            api.emit(node.type + "Comment", node);
-                        });
-                    }
-
+                    emitCommentsEnter(comments.trailing);
                 },
                 leave: function(node) {
 
-                    var comments = api.getComments(node),
-                        leadingComments = comments.leading,
-                        trailingComments = comments.trailing;
-
-                    if (trailingComments.length) {
-                        trailingComments.forEach(function(node) {
-                            api.emit(node.type + "Comment:exit", node);
-                        });
-                    }
+                    var comments = api.getComments(node);
 
+                    emitCommentsExit(comments.trailing);
                     api.emit(node.type + ":exit", node);
-
-                    if (leadingComments.length) {
-                        leadingComments.forEach(function(node) {
-                            api.emit(node.type + "Comment:exit", node);
-                        });
-                    }
+                    emitCommentsExit(comments.leading);
                 }
             });
 
@@ -678,7 +696,7 @@ module.exports = (function() {
             return null;
         }
 
-        switch(node.type) {
+        switch (node.type) {
             case "FunctionDeclaration":
                 return findJSDocComment(node.leadingComments);
 
@@ -708,7 +726,7 @@ module.exports = (function() {
     api.getTokensBefore = function(node, beforeCount) {
         var beforeTokens = [], cursor = node.range[0] - 1;
         while (beforeCount > 0 && cursor >= 0) {
-            if(currentTokens[cursor]) {
+            if (currentTokens[cursor]) {
                 beforeTokens.unshift(currentTokens[cursor]);
                 --beforeCount;
             }
@@ -744,7 +762,7 @@ module.exports = (function() {
     api.getTokensAfter = function(node, afterCount) {
         var afterTokens = [], cursor = node.range[1];
         while (afterCount > 0 && cursor < currentTokens.length) {
-            if(currentTokens[cursor]) {
+            if (currentTokens[cursor]) {
                 afterTokens.push(currentTokens[cursor]);
                 --afterCount;
                 cursor = currentTokens[cursor].range[1];
@@ -786,7 +804,7 @@ module.exports = (function() {
             tokens = [],
             cursor = node.range[0];
         while (cursor < node.range[1]) {
-            if(currentTokens[cursor]) {
+            if (currentTokens[cursor]) {
                 tokens.push(currentTokens[cursor]);
                 cursor = currentTokens[cursor].range[1];
             } else {
@@ -805,7 +823,7 @@ module.exports = (function() {
     api.getFirstTokens = function(node, count) {
         var tokens = [], cursor = node.range[0];
         while (count > 0 && cursor < node.range[1]) {
-            if(currentTokens[cursor]) {
+            if (currentTokens[cursor]) {
                 tokens.push(currentTokens[cursor]);
                 --count;
                 cursor = currentTokens[cursor].range[1];
@@ -843,7 +861,7 @@ module.exports = (function() {
     api.getLastTokens = function(node, count) {
         var tokens = [], cursor = node.range[1] - 1;
         while (count > 0 && cursor >= node.range[0]) {
-            if(currentTokens[cursor]) {
+            if (currentTokens[cursor]) {
                 tokens.unshift(currentTokens[cursor]);
                 --count;
             }

package/lib/formatters/checkstyle.js

@@ -25,7 +25,7 @@ function getMessageType(message, rules) {
 
 function xmlEscape(s) {
     return ("" + s).replace(/[<>&"']/g, function(c) {
-        switch(c) {
+        switch (c) {
             case "<":
                 return "&lt;";
             case ">":
@@ -36,6 +36,7 @@ function xmlEscape(s) {
                 return "&quot;";
             case "'":
                 return "&apos;";
+            // no default
         }
     });
 }

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

@@ -96,6 +96,12 @@ module.exports = function(context) {
         declare(["arguments"]);
     }
 
+    function variableDeclarationHandler(node) {
+        declare(node.declarations.map(function(decl) {
+            return decl.id.name;
+        }));
+    }
+
     return {
         "Program": function() {
             scopeStack = [context.getScope().variables.map(function(v) {
@@ -108,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]);
                 }
@@ -123,13 +127,30 @@ module.exports = function(context) {
             pushScope();
             declare([node.param.name]);
         },
+        "CatchClause:exit": popScope,
 
         "FunctionDeclaration": functionHandler,
-        "FunctionExpression": 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();
             if (isDeclaration(node, ancestor) || isProperty(node, ancestor)) {

package/lib/rules/brace-style.js

@@ -34,7 +34,7 @@ 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);
 
@@ -127,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/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-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":
@@ -94,6 +96,7 @@ module.exports = function(context) {
                 return 16;
             case "NewExpression":
                 return 17;
+            // no default
         }
         return 18;
     }
@@ -103,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);
                 }
             });
@@ -127,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);
         }
     }
@@ -138,69 +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)) {
+            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)) {
+            if (isParenthesised(node.right)) {
                 report(node.right);
             }
         },
         "ForStatement": function(node) {
-            if(node.init && isParenthesised(node.init)) {
+            if (node.init && isParenthesised(node.init)) {
                 report(node.init);
             }
 
-            if(node.test && isParenthesised(node.test)) {
+            if (node.test && isParenthesised(node.test)) {
                 report(node.test);
             }
 
-            if(node.update && isParenthesised(node.update)) {
+            if (node.update && isParenthesised(node.update)) {
                 report(node.update);
             }
         },
         "IfStatement": function(node) {
-            if(isParenthesisedTwice(node.test)) {
+            if (isParenthesisedTwice(node.test)) {
                 report(node.test);
             }
         },
         "LogicalExpression": dryBinaryLogical,
         "MemberExpression": function(node) {
-            if(
+            if (
                 isParenthesised(node.object) &&
                 precedence(node.object) >= precedence(node) &&
                 (
@@ -219,52 +222,52 @@ 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)) {
+            if (node.argument && isParenthesised(node.argument)) {
                 report(node.argument);
             }
         },
         "SequenceExpression": function(node) {
             [].forEach.call(node.expressions, function(e) {
-                if(isParenthesised(e) && precedence(e) >= precedence(node)) {
+                if (isParenthesised(e) && precedence(e) >= precedence(node)) {
                     report(e);
                 }
             });
         },
         "SwitchCase": function(node) {
-            if(node.test && isParenthesised(node.test)) {
+            if (node.test && isParenthesised(node.test)) {
                 report(node.test);
             }
         },
         "SwitchStatement": function(node) {
-            if(isParenthesisedTwice(node.discriminant)) {
+            if (isParenthesisedTwice(node.discriminant)) {
                 report(node.discriminant);
             }
         },
         "ThrowStatement": function(node) {
-            if(isParenthesised(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)) {
+            if (isParenthesisedTwice(node.test)) {
                 report(node.test);
             }
         },
         "WithStatement": function(node) {
-            if(isParenthesisedTwice(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-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-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;
             }
         });

package/lib/rules/no-shadow-restricted-names.js

@@ -13,7 +13,7 @@ module.exports = function(context) {
     var RESTRICTED = ["undefined", "NaN", "Infinity", "arguments", "eval"];
 
     function checkForViolation(id) {
-        if(RESTRICTED.indexOf(id.name) > -1) {
+        if (RESTRICTED.indexOf(id.name) > -1) {
             context.report(id, "Shadowing of global property \"" + id.name + "\".");
         }
     }
@@ -23,7 +23,7 @@ module.exports = function(context) {
             checkForViolation(node.id);
         },
         "FunctionExpression": function(node) {
-            if(node.id) {
+            if (node.id) {
                 checkForViolation(node.id);
             }
             [].map.call(node.params, checkForViolation);

package/lib/rules/no-shadow.js

@@ -39,7 +39,7 @@ module.exports = function(context) {
             });
         }
 
-        while(upper) {
+        while (upper) {
             findDups(variables);
             upper = upper.upper;
         }

package/lib/rules/no-spaced-func.js

@@ -15,7 +15,7 @@ module.exports = function(context) {
         var i, token, hasArgumentList = false, numOpen = 0;
 
         // start at the end of the token stream; skip over argument list contents
-        for(i = tokens.length - 1; i >= 0; --i) {
+        for (i = tokens.length - 1; i >= 0; --i) {
             token = tokens[i];
             if (token.value === "(") {
                 --numOpen;

package/lib/rules/sort-vars.js

@@ -14,7 +14,7 @@ module.exports = function(context) {
     return {
         "VariableDeclaration": function(node) {
             node.declarations.reduce(function(memo, decl) {
-                if(decl.id.name < memo.id.name) {
+                if (decl.id.name < memo.id.name) {
                     context.report(decl, "Variables within the same declaration block should be sorted alphabetically");
                     return memo;
                 } else {

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

@@ -19,9 +19,9 @@ module.exports = function(context) {
 
     function isSpaced(left, right) {
         var op, tokens = context.getTokens({range: [left.range[1], right.range[0]]}, 1, 1);
-        for(var i = 1, l = tokens.length - 1; i < l; ++i) {
+        for (var i = 1, l = tokens.length - 1; i < l; ++i) {
             op = tokens[i];
-            if(
+            if (
                 op.type === "Punctuator" &&
                 OPERATORS.indexOf(op.value) >= 0 &&
                 (tokens[i - 1].range[1] >= op.range[0] || op.range[1] >= tokens[i + 1].range[0])
@@ -34,9 +34,9 @@ module.exports = function(context) {
 
     function isRightSpaced(left, right) {
         var op, tokens = context.getTokens({range: [left.range[1], right.range[0]]}, 1, 1);
-        for(var i = 1, l = tokens.length - 1; i < l; ++i) {
+        for (var i = 1, l = tokens.length - 1; i < l; ++i) {
             op = tokens[i];
-            if(
+            if (
                 op.type === "Punctuator" &&
                 OPERATORS.indexOf(op.value) >= 0 &&
                 op.range[1] >= tokens[i + 1].range[0]
@@ -52,14 +52,14 @@ module.exports = function(context) {
     }
 
     function checkBinary(node) {
-        if(!isSpaced(node.left, node.right)) {
+        if (!isSpaced(node.left, node.right)) {
             report(node);
         }
     }
 
     function checkSequence(node) {
-        for(var i = 0, l = node.expressions.length - 1; i < l; ++i) {
-            if(!isRightSpaced(node.expressions[i], node.expressions[i + 1])) {
+        for (var i = 0, l = node.expressions.length - 1; i < l; ++i) {
+            if (!isRightSpaced(node.expressions[i], node.expressions[i + 1])) {
                 report(node);
                 break;
             }
@@ -67,13 +67,13 @@ module.exports = function(context) {
     }
 
     function checkConditional(node) {
-        if(!isSpaced(node.test, node.consequent) || !isSpaced(node.consequent, node.alternate)) {
+        if (!isSpaced(node.test, node.consequent) || !isSpaced(node.consequent, node.alternate)) {
             report(node);
         }
     }
 
     function checkVar(node) {
-        if(node.init && !isSpaced(node.id, node.init)) {
+        if (node.init && !isSpaced(node.id, node.init)) {
             report(node);
         }
     }

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

@@ -14,19 +14,19 @@ module.exports = function(context) {
         var tokens = context.getFirstTokens(node, 2),
             value = tokens[0].value;
 
-        if(tokens[0].range[1] >= tokens[1].range[0]) {
+        if (tokens[0].range[1] >= tokens[1].range[0]) {
             context.report(node, "Keyword \"" + value + "\" must be followed by whitespace.");
         }
     }
 
     return {
         "ReturnStatement": function(node) {
-            if(node.argument) {
+            if (node.argument) {
                 check(node);
             }
         },
         "SwitchCase": function(node) {
-            if(node.test) {
+            if (node.test) {
                 check(node);
             }
         },

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

@@ -13,14 +13,15 @@ module.exports = function(context) {
     function check(node) {
         var tokens;
         tokens = context.getFirstTokens(node, 2);
-        if(tokens[0].range[1] >= tokens[1].range[0]) {
-            switch(tokens[0].value) {
+        if (tokens[0].range[1] >= tokens[1].range[0]) {
+            switch (tokens[0].value) {
                 case "delete":
                 case "new":
                 case "typeof":
                 case "void":
                     context.report(node, "Unary word operator \"" + tokens[0].value + "\" must be followed by whitespace.");
                     break;
+                // no default
             }
         }
     }

package/lib/rules/valid-jsdoc.js

@@ -129,6 +129,7 @@ module.exports = function(context) {
                         hasConstructor = true;
                         break;
 
+                    // no default
                 }
 
                 // check tag preferences

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An Esprima-based pattern checker for JavaScript.",
   "bin": {
@@ -55,7 +55,7 @@
     "browserify": "~3.20.0",
     "mocha-phantomjs": "~3.3.1",
     "phantomjs": "~1.9.2-6",
-    "eslint-tester": "latest",
+    "eslint-tester": "^0.1.0",
     "brfs": "0.0.9",
     "through": "~2.3.4",
     "beefy": "~1.0.0",