eslint 1.9.0 → 1.10.3

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

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -18,32 +24,12 @@ module.exports = function(context) {
     /**
      * Check if the identifier is present inside current scope
      * @param {object} scope current scope
-     * @param {ASTNode} identifier To evaluate
+     * @param {string} name To evaluate
      * @returns {boolean} True if its present
      * @private
      */
-    function findIdentifier(scope, identifier) {
-        var found = false;
-
-        scope.variables.forEach(function(variable) {
-            if (variable.name === identifier) {
-                found = true;
-            }
-        });
-
-        scope.references.forEach(function(reference) {
-            if (reference.identifier.name === identifier) {
-                found = true;
-            }
-        });
-
-        // If we have not found the identifier in this scope, check the parent
-        // scope.
-        if (scope.upper && !found) {
-            return findIdentifier(scope.upper, identifier);
-        }
-
-        return found;
+    function findIdentifier(scope, name) {
+        return astUtils.getVariableByName(scope, name) !== null;
     }
 
     //--------------------------------------------------------------------------

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

@@ -88,7 +88,7 @@ module.exports = function(context) {
                         // within the file, not at the end
                         if (blankCounter >= max) {
                             context.report(node, location,
-                                    "More than " + max + " blank lines not allowed.");
+                                    "More than " + max + " blank " + (max === 1 ? "line" : "lines") + " not allowed.");
                         }
                     } else {
                         // inside the last blank lines

package/lib/rules/no-sequences.js

@@ -85,7 +85,8 @@ module.exports = function(context) {
                 }
             }
 
-            context.report(node, "Unexpected use of comma operator.");
+            var child = context.getTokenAfter(node.expressions[0]);
+            context.report(node, child.loc.start, "Unexpected use of comma operator.");
         }
     };
 

package/lib/rules/no-shadow.js

@@ -6,6 +6,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -99,70 +105,37 @@ module.exports = function(context) {
         );
     }
 
-    /**
-     * Checks if a variable is contained in the list of given scope variables.
-     * @param {Object} variable The variable to check.
-     * @param {Array} scopeVars The scope variables to look for.
-     * @returns {boolean} Whether or not the variable is contains in the list of scope variables.
-     */
-    function isContainedInScopeVars(variable, scopeVars) {
-        return scopeVars.some(function(scopeVar) {
-            return (
-                (scopeVar.identifiers.length > 0 || (options.builtinGlobals && "writeable" in scopeVar)) &&
-                variable.name === scopeVar.name &&
-                !isDuplicatedClassNameVariable(scopeVar) &&
-                !isOnInitializer(variable, scopeVar) &&
-                !(options.hoist !== "all" && isInTdz(variable, scopeVar))
-            );
-        });
-    }
-
-    /**
-     * Checks if the given variables are shadowed in the given scope.
-     * @param {Array} variables The variables to look for
-     * @param {Object} scope The scope to be checked.
-     * @returns {Array} Variables which are not declared in the given scope.
-     */
-    function checkShadowsInScope(variables, scope) {
-
-        var passedVars = [];
-
-        variables.forEach(function(variable) {
-            // "arguments" is a special case that has no identifiers (#1759)
-            if (variable.identifiers.length > 0 && isContainedInScopeVars(variable, scope.variables)) {
-                context.report(
-                    variable.identifiers[0],
-                    "\"{{name}}\" is already declared in the upper scope.",
-                    {name: variable.name});
-            } else {
-                passedVars.push(variable);
-            }
-        });
-
-        return passedVars;
-    }
-
     /**
      * Checks the current context for shadowed variables.
      * @param {Scope} scope - Fixme
      * @returns {void}
      */
     function checkForShadows(scope) {
-        var variables = scope.variables.filter(function(variable) {
-            return (
-                // Skip "arguments".
-                variable.identifiers.length > 0 &&
-                // Skip variables of a class name in the class scope of ClassDeclaration.
-                !isDuplicatedClassNameVariable(variable) &&
-                !isAllowed(variable)
-            );
-        });
-
-        // iterate through the array of variables and find duplicates with the upper scope
-        var upper = scope.upper;
-        while (upper && variables.length) {
-            variables = checkShadowsInScope(variables, upper);
-            upper = upper.upper;
+        var variables = scope.variables;
+        for (var i = 0; i < variables.length; ++i) {
+            var variable = variables[i];
+
+            // Skips "arguments" or variables of a class name in the class scope of ClassDeclaration.
+            if (variable.identifiers.length === 0 ||
+                isDuplicatedClassNameVariable(variable) ||
+                isAllowed(variable)
+            ) {
+                continue;
+            }
+
+            // Gets shadowed variable.
+            var shadowed = astUtils.getVariableByName(scope.upper, variable.name);
+            if (shadowed &&
+                (shadowed.identifiers.length > 0 || (options.builtinGlobals && "writeable" in shadowed)) &&
+                !isOnInitializer(variable, shadowed) &&
+                !(options.hoist !== "all" && isInTdz(variable, shadowed))
+            ) {
+                context.report({
+                    node: variable.identifiers[0],
+                    message: "\"{{name}}\" is already declared in the upper scope.",
+                    data: variable
+                });
+            }
         }
     }
 

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

@@ -21,26 +21,30 @@ module.exports = function(context) {
      */
     function detectOpenSpaces(node) {
         var lastCalleeToken = sourceCode.getLastToken(node.callee),
-            tokens = sourceCode.getTokens(node),
-            i = tokens.indexOf(lastCalleeToken),
-            l = tokens.length;
-
-        while (i < l && tokens[i].value !== "(") {
-            ++i;
-        }
-
-        if (i >= l) {
-            return;
+            prevToken = lastCalleeToken,
+            parenToken = sourceCode.getTokenAfter(lastCalleeToken);
+
+        // advances to an open parenthesis.
+        while (
+            parenToken &&
+            parenToken.range[1] < node.range[1] &&
+            parenToken.value !== "("
+        ) {
+            prevToken = parenToken;
+            parenToken = sourceCode.getTokenAfter(parenToken);
         }
 
         // look for a space between the callee and the open paren
-        if (sourceCode.isSpaceBetweenTokens(tokens[i - 1], tokens[i])) {
+        if (parenToken &&
+            parenToken.range[1] < node.range[1] &&
+            sourceCode.isSpaceBetweenTokens(prevToken, parenToken)
+        ) {
             context.report({
                 node: node,
                 loc: lastCalleeToken.loc.start,
                 message: "Unexpected space between function name and paren.",
                 fix: function(fixer) {
-                    return fixer.removeRange([tokens[i - 1].range[1], tokens[i].range[0]]);
+                    return fixer.removeRange([prevToken.range[1], parenToken.range[0]]);
                 }
             });
         }

package/lib/rules/no-undef-init.js

@@ -1,6 +1,8 @@
 /**
  * @fileoverview Rule to flag when initializing to undefined
  * @author Ilya Volodin
+ * @copyright 2013 Ilya Volodin. All rights reserved.
+ * See LICENSE in root directory for full license.
  */
 
 "use strict";
@@ -14,10 +16,10 @@ module.exports = function(context) {
     return {
 
         "VariableDeclarator": function(node) {
-            var name = node.id.name;
-            var init = node.init && node.init.name;
+            var name = node.id.name,
+                init = node.init && node.init.name;
 
-            if (init === "undefined") {
+            if (init === "undefined" && node.parent.kind !== "const") {
                 context.report(node, "It's not necessary to initialize '{{name}}' to undefined.", { name: name });
             }
         }

package/lib/rules/no-undef.js

@@ -10,12 +10,14 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-// none!
+var astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
 /**
  * Check if a variable is an implicit declaration
  * @param {ASTNode} variable node to evaluate
@@ -35,18 +37,13 @@ function isImplicitGlobal(variable) {
  * @returns {Variable} The variable, or null if ref refers to an undeclared variable.
  */
 function getDeclaredGlobalVariable(scope, ref) {
-    var declaredGlobal = null;
-    scope.variables.some(function(variable) {
-        if (variable.name === ref.identifier.name) {
-            // If it's an implicit global, it must have a `writeable` field (indicating it was declared)
-            if (!isImplicitGlobal(variable) || {}.hasOwnProperty.call(variable, "writeable")) {
-                declaredGlobal = variable;
-                return true;
-            }
-        }
-        return false;
-    });
-    return declaredGlobal;
+    var variable = astUtils.getVariableByName(scope, ref.identifier.name);
+
+    // If it's an implicit global, it must have a `writeable` field (indicating it was declared)
+    if (variable && (!isImplicitGlobal(variable) || hasOwnProperty.call(variable, "writeable"))) {
+        return variable;
+    }
+    return null;
 }
 
 /**

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

@@ -6,6 +6,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Constants
 //------------------------------------------------------------------------------
@@ -18,26 +24,6 @@ var NO_FUNC = "nofunc";
 
 module.exports = function(context) {
 
-    /**
-     * Finds variable declarations in a given scope.
-     * @param {string} name The variable name to find.
-     * @param {Scope} scope The scope to search in.
-     * @returns {Object} The variable declaration object.
-     * @private
-     */
-    function findDeclaration(name, scope) {
-        // try searching in the current scope first
-        for (var i = 0, l = scope.variables.length; i < l; i++) {
-            if (scope.variables[i].name === name) {
-                return scope.variables[i];
-            }
-        }
-        // check if there's upper scope and call recursivly till we find the variable
-        if (scope.upper) {
-            return findDeclaration(name, scope.upper);
-        }
-    }
-
     /**
      * Finds and validates all variables in a given scope.
      * @param {Scope} scope The scope object.
@@ -68,7 +54,7 @@ module.exports = function(context) {
             if (reference.resolved && reference.resolved.identifiers.length > 0) {
                 checkLocationAndReport(reference, reference.resolved);
             } else {
-                var declaration = findDeclaration(reference.identifier.name, scope);
+                var declaration = astUtils.getVariableByName(scope, reference.identifier.name);
                 // if there're no identifiers, this is a global environment variable
                 if (declaration && declaration.identifiers.length !== 0) {
                     checkLocationAndReport(reference, declaration);

package/lib/rules/operator-linebreak.js

@@ -6,7 +6,8 @@
 
 "use strict";
 
-var astUtils = require("../ast-utils");
+var assign = require("object-assign"),
+    astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -17,7 +18,7 @@ module.exports = function(context) {
     var usedDefaultGlobal = !context.options[0];
     var globalStyle = context.options[0] || "after";
     var options = context.options[1] || {};
-    var styleOverrides = options.overrides || {};
+    var styleOverrides = options.overrides ? assign({}, options.overrides) : {};
 
     if (usedDefaultGlobal && !styleOverrides["?"]) {
         styleOverrides["?"] = "before";

package/lib/rules/quotes.js

@@ -11,9 +11,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-var astUtils = require("../ast-utils"),
-    toSingleQuotes = require("to-single-quotes"),
-    toDoubleQuotes = require("to-double-quotes");
+var astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
 // Constants
@@ -23,27 +21,48 @@ var QUOTE_SETTINGS = {
     "double": {
         quote: "\"",
         alternateQuote: "'",
-        description: "doublequote",
-        convert: function(str) {
-            return toDoubleQuotes(str);
-        }
+        description: "doublequote"
     },
     "single": {
         quote: "'",
         alternateQuote: "\"",
-        description: "singlequote",
-        convert: function(str) {
-            return toSingleQuotes(str);
-        }
+        description: "singlequote"
     },
     "backtick": {
         quote: "`",
         alternateQuote: "\"",
-        description: "backtick",
-        convert: function(str) {
-            return str.replace(/`/g, "\`").replace(/^(?:\\*)["']|(?:\\*)["']$/g, "`");
-        }
+        description: "backtick"
+    }
+};
+/**
+ * Switches quoting of javascript string between ' " and `
+ * escaping and unescaping as necessary.
+ * Only escaping of the minimal set of characters is changed.
+ * Note: escaping of newlines when switching from backtick to other quotes is not handled.
+ * @param {string} str - A string to convert.
+ * @returns {string} The string with changed quotes.
+ * @private
+ */
+QUOTE_SETTINGS.double.convert =
+QUOTE_SETTINGS.single.convert =
+QUOTE_SETTINGS.backtick.convert = function(str) {
+    var newQuote = this.quote;
+    var oldQuote = str[0];
+    if (newQuote === oldQuote) {
+        return str;
     }
+    return newQuote + str.slice(1, -1).replace(/\\(\${|\r\n?|\n|.)|["'`]|\${|(\r\n?|\n)/g, function(match, escaped, newline) {
+        if (escaped === oldQuote || oldQuote === "`" && escaped === "${") {
+            return escaped; // unescape
+        }
+        if (match === newQuote || newQuote === "`" && match === "${") {
+            return "\\" + match; // escape
+        }
+        if (newline && oldQuote === "`") {
+            return "\\n"; // escape newlines
+        }
+        return match;
+    }) + newQuote;
 };
 
 var AVOID_ESCAPE = "avoid-escape",

package/lib/rules/require-jsdoc.js

@@ -5,8 +5,16 @@
  */
 "use strict";
 
+var assign = require("object-assign");
+
 module.exports = function(context) {
     var source = context.getSourceCode();
+    var DEFAULT_OPTIONS = {
+        "FunctionDeclaration": true,
+        "MethodDefinition": false,
+        "ClassDeclaration": false
+    };
+    var options = assign(DEFAULT_OPTIONS, context.options[0] && context.options[0].require || {});
 
     /**
      * Report the error message
@@ -17,6 +25,21 @@ module.exports = function(context) {
         context.report(node, "Missing JSDoc comment.");
     }
 
+    /**
+     * Check if the jsdoc comment is present for class methods
+     * @param {ASTNode} node node to examine
+     * @returns {void}
+     */
+    function checkClassMethodJsDoc(node) {
+        if (node.parent.type === "MethodDefinition") {
+            var jsdocComment = source.getJSDocComment(node);
+
+            if (!jsdocComment) {
+                report(node);
+            }
+        }
+    }
+
     /**
      * Check if the jsdoc comment is present or not.
      * @param {ASTNode} node node to examine
@@ -31,8 +54,44 @@ module.exports = function(context) {
     }
 
     return {
-        "FunctionDeclaration": checkJsDoc
+        "FunctionDeclaration": function(node) {
+            if (options.FunctionDeclaration) {
+                checkJsDoc(node);
+            }
+        },
+        "FunctionExpression": function(node) {
+            if (options.MethodDefinition) {
+                checkClassMethodJsDoc(node);
+            }
+        },
+        "ClassDeclaration": function(node) {
+            if (options.ClassDeclaration) {
+                checkJsDoc(node);
+            }
+        }
     };
 };
 
-module.exports.schema = [];
+module.exports.schema = [
+    {
+        "type": "object",
+        "properties": {
+            "require": {
+                "type": "object",
+                "properties": {
+                    "ClassDeclaration": {
+                        "type": "boolean"
+                    },
+                    "MethodDefinition": {
+                        "type": "boolean"
+                    },
+                    "FunctionDeclaration": {
+                        "type": "boolean"
+                    }
+                },
+                "additionalProperties": false
+            }
+        },
+        "additionalProperties": false
+    }
+];

package/lib/rules/space-after-keywords.js

@@ -33,6 +33,7 @@ module.exports = function(context) {
         if (hasSpace !== requiresSpace) {
             context.report({
                 node: node,
+                loc: left.loc.end,
                 message: "Keyword \"{{value}}\" must {{not}}be followed by whitespace.",
                 data: {
                     value: value,
@@ -49,6 +50,7 @@ module.exports = function(context) {
         } else if (left.loc.end.line !== right.loc.start.line) {
             context.report({
                 node: node,
+                loc: left.loc.end,
                 message: "Keyword \"{{value}}\" must not be followed by a newline.",
                 data: {
                     value: value

package/lib/rules/space-before-function-paren.js

@@ -37,7 +37,7 @@ module.exports = function(context) {
             return true;
         }
 
-        parent = context.getAncestors().pop();
+        parent = node.parent;
         return parent.type === "MethodDefinition" ||
             (parent.type === "Property" &&
                 (
@@ -55,7 +55,6 @@ module.exports = function(context) {
      */
     function validateSpacingBeforeParentheses(node) {
         var isNamed = isNamedFunction(node),
-            tokens,
             leftToken,
             rightToken,
             location;
@@ -64,31 +63,11 @@ module.exports = function(context) {
             return;
         }
 
-        tokens = context.getTokens(node);
-
-        if (node.generator) {
-            if (node.id) {
-                leftToken = tokens[2];
-                rightToken = tokens[3];
-            } else {
-                // Object methods are named but don't have an id
-                leftToken = context.getTokenBefore(node);
-                rightToken = tokens[0];
-            }
-        } else if (isNamed) {
-            if (node.id) {
-                leftToken = tokens[1];
-                rightToken = tokens[2];
-            } else {
-                // Object methods are named but don't have an id
-                leftToken = context.getTokenBefore(node);
-                rightToken = tokens[0];
-            }
-        } else {
-            leftToken = tokens[0];
-            rightToken = tokens[1];
+        rightToken = sourceCode.getFirstToken(node);
+        while (rightToken.value !== "(") {
+            rightToken = sourceCode.getTokenAfter(rightToken);
         }
-
+        leftToken = context.getTokenBefore(rightToken);
         location = leftToken.loc.end;
 
         if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken)) {

package/lib/rules/space-before-keywords.js

@@ -134,7 +134,10 @@ module.exports = function(context) {
             check(node);
             // else
             if (node.alternate) {
-                check(context.getTokenBefore(node.alternate), { requireSpace: SPACE_REQUIRED });
+                var tokens = context.getTokensBefore(node.alternate, 2);
+                if (tokens[0].value === "}") {
+                    check(tokens[1], { requireSpace: SPACE_REQUIRED });
+                }
             }
         },
         "ForStatement": check,
@@ -185,7 +188,7 @@ module.exports = function(context) {
                 return;
             }
 
-            checkTokens(node, left, right, { allowedPrecedingChars: [ "(", "{" ] });
+            checkTokens(node, left, right, { allowedPrecedingChars: [ "(", "{", "[" ] });
         },
         "YieldExpression": function(node) {
             check(node, { allowedPrecedingChars: [ "(", "{" ] });

package/lib/rules/spaced-comment.js

@@ -41,9 +41,7 @@ function escapeAndRepeat(s) {
  * @returns {string[]} A marker list.
  */
 function parseMarkersOption(markers) {
-    if (!markers) {
-        markers = [];
-    }
+    markers = markers ? markers.slice(0) : [];
 
     // `*` is a marker for JSDoc comments.
     if (markers.indexOf("*") === -1) {

package/lib/rules/valid-jsdoc.js

@@ -24,7 +24,8 @@ module.exports = function(context) {
         // these both default to true, so you have to explicitly make them false
         requireReturn = options.requireReturn !== false,
         requireParamDescription = options.requireParamDescription !== false,
-        requireReturnDescription = options.requireReturnDescription !== false;
+        requireReturnDescription = options.requireReturnDescription !== false,
+        requireReturnType = options.requireReturnType !== false;
 
     //--------------------------------------------------------------------------
     // Helpers
@@ -77,7 +78,7 @@ module.exports = function(context) {
      * @private
      */
     function isValidReturnType(tag) {
-        return tag.type.name === "void" || tag.type.type === "UndefinedLiteral";
+        return tag.type === null || tag.type.name === "void" || tag.type.type === "UndefinedLiteral";
     }
 
     /**
@@ -141,10 +142,10 @@ module.exports = function(context) {
                     case "returns":
                         hasReturns = true;
 
-                        if (!requireReturn && !functionData.returnPresent && tag.type.name !== "void" && tag.type.name !== "undefined") {
+                        if (!requireReturn && !functionData.returnPresent && (tag.type === null || !isValidReturnType(tag))) {
                             context.report(jsdocNode, "Unexpected @" + tag.title + " tag; function has no return statement.");
                         } else {
-                            if (!tag.type) {
+                            if (requireReturnType && !tag.type) {
                                 context.report(jsdocNode, "Missing JSDoc return type.");
                             }
 
@@ -258,6 +259,9 @@ module.exports.schema = [
             },
             "matchDescription": {
                 "type": "string"
+            },
+            "requireReturnType": {
+                "type": "boolean"
             }
         },
         "additionalProperties": false