eslint 0.5.0 → 0.6.2

package/lib/rules/no-new-require.js

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Rule to disallow use of new operator with the `require` function
+ * @author Wil Moore III
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    "use strict";
+
+    return {
+
+        "NewExpression": function(node) {
+            if (node.callee.type === "Identifier" && node.callee.name === "require") {
+                context.report(node, "Unexpected use of new with require.");
+            }
+        }
+    };
+
+};

package/lib/rules/no-redeclare.js

@@ -16,7 +16,10 @@ module.exports = function(context) {
 
         scope.variables.forEach(function(variable) {
             if (variable.identifiers && variable.identifiers.length > 1) {
-                variable.identifiers.sort(function(a, b) { return a.range[1] - b.range[1];});
+                variable.identifiers.sort(function(a, b) {
+                    return a.range[1] - b.range[1];
+                });
+
                 for (var i = 1, l = variable.identifiers.length; i < l; i++) {
                     context.report(variable.identifiers[i], "{{a}} is already defined", {a: variable.name});
                 }

package/lib/rules/no-restricted-modules.js

@@ -0,0 +1,72 @@
+/**
+ * @fileoverview Restrict usage of specified node modules.
+ * @author Christian Schulz
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function (context) {
+    // trim restricted module names
+    var restrictedModules = context.options;
+
+    // if no modules are restricted we don't need to check the CallExpressions
+    if (restrictedModules.length === 0) {
+        return {};
+    }
+
+    /**
+     * Function to check if a node is a string literal.
+     * @param {ASTNode} node The node to check.
+     * @returns {boolean} If the node is a string literal.
+     */
+    function isString(node) {
+        return node && node.type === "Literal" && typeof node.value === "string";
+    }
+
+    /**
+     * Function to check if a node is a require call.
+     * @param {ASTNode} node The node to check.
+     * @returns {boolean} If the node is a require call.
+     */
+    function isRequireCall(node) {
+        return node.callee.type === "Identifier" && node.callee.name === "require";
+    }
+
+    /**
+     * Function to check if a node has an argument that is an restricted module and return its name.
+     * @param {ASTNode} node The node to check
+     * @returns {undefined|String} restricted module name or undefined if node argument isn't restricted.
+     */
+    function getRestrictedModuleName(node) {
+        var moduleName;
+
+        // node has arguments and first argument is string
+        if (node.arguments.length && isString(node.arguments[0])) {
+            var argumentValue = node.arguments[0].value.trim();
+
+            // check if argument value is in restricted modules array
+            if (restrictedModules.indexOf(argumentValue) !== -1) {
+                moduleName = argumentValue;
+            }
+        }
+
+        return moduleName;
+    }
+
+    return {
+        "CallExpression": function (node) {
+            if (isRequireCall(node)) {
+                var restrictedModuleName = getRestrictedModuleName(node);
+
+                if (restrictedModuleName) {
+                    context.report(node, "'{{moduleName}}' module is restricted from being used.", {
+                        moduleName: restrictedModuleName
+                    });
+                }
+            }
+        }
+    };
+};

package/lib/rules/no-sequences.js

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Rule to flag use of comma operator
+ * @author Brandon Mills
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    "use strict";
+
+    /**
+     * Parts of the grammar that are required to have parens.
+     */
+    var parenthesized = {
+        "DoWhileStatement": "test",
+        "IfStatement": "test",
+        "SwitchStatement": "discriminant",
+        "WhileStatement": "test",
+        "WithStatement": "object"
+
+        // Omitting CallExpression - commas are parsed as argument separators
+        // Omitting NewExpression - commas are parsed as argument separators
+        // Omitting ForInStatement - parts aren't individually parenthesised
+        // Omitting ForStatement - parts aren't individually parenthesised
+    };
+
+    /**
+     * Determines whether a node is required by the grammar to be wrapped in
+     * parens, e.g. the test of an if statement.
+     * @param {ASTNode} node - The AST node
+     * @returns {boolean} True if parens around node belong to parent node.
+     */
+    function requiresExtraParens(node) {
+        return node.parent && parenthesized[node.parent.type] !== undefined &&
+                node === node.parent[parenthesized[node.parent.type]];
+    }
+
+    /**
+     * Check if a node is wrapped in parens.
+     * @param {ASTNode} node - The AST node
+     * @returns {boolean} True if the node has a paren on each side.
+     */
+    function isParenthesised(node) {
+        var previousToken = context.getTokenBefore(node),
+            nextToken = context.getTokenAfter(node);
+
+        return previousToken && nextToken &&
+            previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
+            nextToken.value === ")" && nextToken.range[0] >= node.range[1];
+    }
+
+    /**
+     * Check if a node is wrapped in two levels of parens.
+     * @param {ASTNode} node - The AST node
+     * @returns {boolean} True if two parens surround the node on each side.
+     */
+    function isParenthesisedTwice(node) {
+        var previousToken = context.getTokenBefore(node, 1),
+            nextToken = context.getTokenAfter(node, 1);
+
+        return isParenthesised(node) && previousToken && nextToken &&
+            previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
+            nextToken.value === ")" && nextToken.range[0] >= node.range[1];
+    }
+
+    return {
+        "SequenceExpression": function(node) {
+            // Always allow sequences in for statement update
+            if (node.parent.type === "ForStatement" &&
+                    (node === node.parent.init || node === node.parent.update)) {
+                return;
+            }
+
+            // Wrapping a sequence in extra parens indicates intent
+            if (requiresExtraParens(node)) {
+                if (isParenthesisedTwice(node)) {
+                    return;
+                }
+            } else {
+                if (isParenthesised(node)) {
+                    return;
+                }
+            }
+
+            context.report(node, "Unexpected use of comma operator.");
+        }
+    };
+
+};

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,9 @@ module.exports = function(context) {
             checkForViolation(node.id);
         },
         "FunctionExpression": function(node) {
-            if(node.id) { checkForViolation(node.id); }
+            if (node.id) {
+                checkForViolation(node.id);
+            }
             [].map.call(node.params, checkForViolation);
         },
         "FunctionDeclaration": function(node) {

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;
@@ -36,11 +36,13 @@ module.exports = function(context) {
             callee = tokens[openParenIndex - 1];
 
         // openParenIndex will be undefined for a NewExpression with no argument list
-        if (!openParenIndex) { return; }
+        if (!openParenIndex) {
+            return;
+        }
 
         // look for a space between the callee and the open paren
         if (callee.range[1] !== openParen.range[0]) {
-            context.report(node, "Spaced function application is not allowed.");
+            context.report(node, "Unexpected space between function name and paren.");
         }
     }
 

package/lib/rules/no-sparse-arrays.js

@@ -19,9 +19,7 @@ module.exports = function(context) {
 
         "ArrayExpression": function(node) {
 
-            var emptySpot = node.elements.some(function(value) {
-                return value === null;
-            });
+            var emptySpot = node.elements.indexOf(null) > -1;
 
             if (emptySpot) {
                 context.report(node, "Unexpected comma in middle of array.");

package/lib/rules/no-unused-vars.js

@@ -12,9 +12,10 @@
 module.exports = function(context) {
 
     var config = {
-        vars: "local",
+        vars: "all",
         args: "after-used"
     };
+
     if (context.options[0]) {
         if (typeof(context.options[0]) === "string") {
             config.vars = context.options[0];
@@ -27,6 +28,7 @@ module.exports = function(context) {
     var allowUnusedGlobals = (config.vars !== "all"),
         variables = {};
 
+
     function lookupVariableName(name) {
 
         // Convoluted check in case name is "hasOwnProperty"
@@ -40,9 +42,7 @@ module.exports = function(context) {
         var candidates = lookupVariableName(variable.name);
         if (candidates) {
             return candidates.filter(function (candidate) {
-                return variable.identifiers.some(function (identifier) {
-                    return candidate.node === identifier;
-                });
+                return variable.identifiers.indexOf(candidate.node) > -1;
             })[0];
         }
         return candidates;
@@ -101,6 +101,12 @@ module.exports = function(context) {
         return lookupVariable(scopeVariable[0]);
     }
 
+    /**
+     * Determines if the given node represents a function.
+     * @param {ASTNode} node The node to check.
+     * @returns {boolean} True if the node represents a function, false if not.
+     * @private
+     */
     function isFunction(node) {
         return node && node.type && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression");
     }

package/lib/rules/no-use-before-define.js

@@ -3,6 +3,12 @@
  * @author Ilya Volodin
  */
 
+//------------------------------------------------------------------------------
+// Constants
+//------------------------------------------------------------------------------
+
+var NO_FUNC = "nofunc";
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -26,10 +32,13 @@ module.exports = function(context) {
 
     function findVariables() {
         var scope = context.getScope();
+        var typeOption = context.options[0];
 
         function checkLocationAndReport(reference, declaration) {
-            if (declaration.identifiers[0].range[1] > reference.identifier.range[1]) {
-                context.report(reference.identifier, "{{a}} was used before it was defined", {a: reference.identifier.name});
+            if (typeOption !== NO_FUNC || declaration.defs[0].type !== "FunctionName") {
+                if (declaration.identifiers[0].range[1] > reference.identifier.range[1]) {
+                    context.report(reference.identifier, "{{a}} was used before it was defined", {a: reference.identifier.name});
+                }
             }
         }
 

package/lib/rules/semi.js

@@ -9,6 +9,8 @@
 //------------------------------------------------------------------------------
 module.exports = function(context) {
 
+    var OPT_OUT_PATTERN = /[\[\(\/\+\-]/;
+
     var always = context.options[0] !== "never";
 
     //--------------------------------------------------------------------------
@@ -21,7 +23,8 @@ module.exports = function(context) {
      * @returns {void}
      */
     function checkForSemicolon(node) {
-        var lastToken = context.getLastToken(node);
+        var lastToken = context.getLastToken(node),
+            nextToken = context.getTokenAfter(node);
 
         if (always) {
             if (lastToken.type !== "Punctuator" || lastToken.value !== ";") {
@@ -29,7 +32,11 @@ module.exports = function(context) {
             }
         } else {
             if (lastToken.type === "Punctuator" && lastToken.value === ";") {
-                context.report(node, node.loc.end, "Extra semicolon.");
+
+                if (!nextToken || !(OPT_OUT_PATTERN.test(nextToken.value))) {
+                    context.report(node, node.loc.end, "Extra semicolon.");
+                }
+
             }
         }
     }
@@ -69,7 +76,8 @@ module.exports = function(context) {
 
             if (!always) {
                 nextToken = context.getTokenAfter(node) || context.getLastToken(node);
-                if (!(/[\[\(\/\+\-]/.test(nextToken.value))) {
+
+                if (!(OPT_OUT_PATTERN.test(nextToken.value))) {
                     context.report(node, "Extra semicolon.");
                 }
             }

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-after-keywords.js

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview Rule to enforce the number of spaces after certain keywords
+ * @author Nick Fisher
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    // unless the first option is `"never"`, then a space is required
+    var requiresSpace = context.options[0] !== "never";
+
+    /**
+     * Check if the separation of two adjacent tokens meets the spacing rules, and report a problem if not.
+     *
+     * @param {ASTNode} node  The node to which the potential problem belongs.
+     * @param {Token} left    The first token.
+     * @param {Token} right   The second token
+     * @returns {void}
+     */
+    function checkTokens(node, left, right) {
+        var hasSpace = left.range[1] < right.range[0],
+            value = left.value;
+
+        if (hasSpace !== requiresSpace) {
+            context.report(node, "Keyword \"{{value}}\" must {{not}}be followed by whitespace.", {
+                value: value,
+                not: requiresSpace ? "" : "not "
+            });
+        }
+    }
+
+    /**
+     * Check if the given node (`if`, `for`, `while`, etc), has the correct spacing after it.
+     * @param {ASTNode} node The node to check.
+     * @returns {void}
+     */
+    function check(node) {
+        var tokens = context.getFirstTokens(node, 2);
+        checkTokens(node, tokens[0], tokens[1]);
+
+        // check the `else` of an `if`.
+        if (tokens[0].value === "if" && node.alternate) {
+            checkTokens(node.alternate, context.getTokenBefore(node.alternate), context.getFirstToken(node.alternate));
+        }
+    }
+
+    return {
+        "IfStatement": check,
+        "ForStatement": check,
+        "ForOfStatement": check,
+        "ForInStatement": check,
+        "WhileStatement": check,
+        "DoWhileStatement": check,
+        "SwitchStatement": check,
+        "TryStatement": check,
+        "CatchStatement": check,
+        "WithStatement": check
+    };
+};
+

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,12 +52,14 @@ module.exports = function(context) {
     }
 
     function checkBinary(node) {
-        if(!isSpaced(node.left, node.right)) { report(node); }
+        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;
             }
@@ -65,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,14 +14,22 @@ 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) { check(node); } },
-        "SwitchCase": function(node) { if(node.test) { check(node); } },
+        "ReturnStatement": function(node) {
+            if (node.argument) {
+                check(node);
+            }
+        },
+        "SwitchCase": function(node) {
+            if (node.test) {
+                check(node);
+            }
+        },
         "ThrowStatement": check
     };
 

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

@@ -18,7 +18,10 @@ module.exports = function(context) {
 
     var options = context.options[0] || {},
         prefer = options.prefer || {},
-        requireReturn = options.requireReturn === false ? false : true;
+
+        // these both default to true, so you have to explicitly make them false
+        requireReturn = options.requireReturn === false ? false : true,
+        requireParamDescription = options.requireParamDescription === false ? false : true;
 
     //--------------------------------------------------------------------------
     // Helpers
@@ -27,11 +30,21 @@ module.exports = function(context) {
     // Using a stack to store if a function returns or not (handling nested functions)
     var fns = [];
 
-    // When parsing a new function, store it in our function stack
+    /**
+     * When parsing a new function, store it in our function stack.
+     * @returns {void}
+     * @private
+     */
     function startFunction() {
         fns.push({returnPresent: false});
     }
 
+    /**
+     * Indicate that return has been found in the current function.
+     * @param {ASTNode} node The return node.
+     * @returns {void}
+     * @private
+     */
     function addReturn(node) {
         var functionState = fns[fns.length - 1];
 
@@ -44,6 +57,7 @@ module.exports = function(context) {
      * Validate the JSDoc node and output warnings if anything is wrong.
      * @param {ASTNode} node The AST node to check.
      * @returns {void}
+     * @private
      */
     function checkJSDoc(node) {
         var jsdocNode = context.getJSDocComment(node),
@@ -82,7 +96,7 @@ module.exports = function(context) {
                             context.report(jsdocNode, "Missing JSDoc parameter type for '{{name}}'.", { name: tag.name });
                         }
 
-                        if (!tag.description) {
+                        if (!tag.description && requireParamDescription) {
                             context.report(jsdocNode, "Missing JSDoc parameter description for '{{name}}'.", { name: tag.name });
                         }
 
@@ -115,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.5.0",
+  "version": "0.6.2",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An Esprima-based pattern checker for JavaScript.",
   "bin": {
@@ -32,9 +32,9 @@
   "homepage": "http://eslint.org",
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
-    "optionator": "~0.3.0",
+    "optionator": "^0.4.0",
     "estraverse": "~1.3.0",
-    "esprima": "~1.1.1",
+    "esprima": "^1.2.0",
     "escope": "~1.0.0",
     "glob": "~3.2.7",
     "text-table": "~0.2.0",
@@ -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",
@@ -68,5 +68,8 @@
     "ecmascript"
   ],
   "preferGlobal": true,
-  "license": "MIT"
+  "license": "MIT",
+  "engines": {
+    "node": ">=0.10"
+  }
 }