eslint 1.7.1 → 1.9.0

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

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

package/lib/rules/no-plusplus.js

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

package/lib/rules/no-shadow.js

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

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

@@ -57,7 +57,7 @@ module.exports = function(context) {
         function checkLocationAndReport(reference, declaration) {
             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});
+                    context.report(reference.identifier, "\"{{a}}\" was used before it was defined", {a: reference.identifier.name});
                 }
             }
         }

package/lib/rules/no-warning-comments.js

@@ -79,7 +79,7 @@ module.exports = function(context) {
         var matches = commentContainsWarningTerm(node.value);
 
         matches.forEach(function(matchedTerm) {
-            context.report(node, "Unexpected " + matchedTerm + " comment.");
+            context.report(node, "Unexpected \"" + matchedTerm + "\" comment.");
         });
     }
 

package/lib/rules/radix.js

@@ -11,6 +11,11 @@
 
 module.exports = function(context) {
 
+    var MODE_ALWAYS = "always",
+        MODE_AS_NEEDED = "as-needed";
+
+    var mode = context.options[0] || MODE_ALWAYS;
+
     return {
         "CallExpression": function(node) {
 
@@ -25,17 +30,37 @@ module.exports = function(context) {
                 return;
             }
 
-            if (node.arguments.length < 2) {
-                context.report(node, "Missing radix parameter.");
+            if (node.arguments.length === 0) {
+                context.report({
+                    node: node,
+                    message: "Missing parameters."
+                });
+            } else if (node.arguments.length < 2 && mode === MODE_ALWAYS) {
+                context.report({
+                    node: node,
+                    message: "Missing radix parameter."
+                });
+            } else if (node.arguments.length > 1 && mode === MODE_AS_NEEDED &&
+                (node.arguments[1] && node.arguments[1].type === "Literal" &&
+                    node.arguments[1].value === 10)
+            ) {
+                context.report({
+                    node: node,
+                    message: "Redundant radix parameter."
+                });
             } else {
 
                 radix = node.arguments[1];
 
                 // don't allow non-numeric literals or undefined
-                if ((radix.type === "Literal" && typeof radix.value !== "number") ||
-                    (radix.type === "Identifier" && radix.name === "undefined")
+                if (radix &&
+                    ((radix.type === "Literal" && typeof radix.value !== "number") ||
+                    (radix.type === "Identifier" && radix.name === "undefined"))
                 ) {
-                    context.report(node, "Invalid radix parameter.");
+                    context.report({
+                        node: node,
+                        message: "Invalid radix parameter."
+                    });
                 }
             }
 
@@ -44,4 +69,9 @@ module.exports = function(context) {
 
 };
 
-module.exports.schema = [];
+module.exports.schema = [
+    {
+        "enum": ["always", "as-needed"]
+    }
+];
+