eslint 1.7.3 → 1.8.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;
             });
 
-            // a single empty line at the end is a valid case regardless of the value of "max" option
-            if (trimmedLines[trimmedLines.length - 2] !== "" &&
-                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,
+                                    "Multiple 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.");
+                        }
                     }
 
                     // 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.
      *
@@ -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/space-in-parens.js

@@ -6,6 +6,8 @@
  */
 "use strict";
 
+var astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -14,258 +16,201 @@ module.exports = function(context) {
 
     var MISSING_SPACE_MESSAGE = "There must be a space inside this paren.",
         REJECTED_SPACE_MESSAGE = "There should be no spaces inside this paren.",
-        exceptionsArray = (context.options.length === 2) ? context.options[1].exceptions : [],
+        ALWAYS = context.options[0] === "always",
+
+        exceptionsArrayOptions = (context.options.length === 2) ? context.options[1].exceptions : [],
         options = {},
-        rejectedSpaceRegExp,
-        missingSpaceRegExp,
-        spaceChecks;
-
-    if (exceptionsArray && exceptionsArray.length) {
-        options.braceException = exceptionsArray.indexOf("{}") !== -1 || false;
-        options.bracketException = exceptionsArray.indexOf("[]") !== -1 || false;
-        options.parenException = exceptionsArray.indexOf("()") !== -1 || false;
-        options.empty = exceptionsArray.indexOf("empty") !== -1 || false;
+        exceptions;
+
+    if (exceptionsArrayOptions.length) {
+        options.braceException = exceptionsArrayOptions.indexOf("{}") !== -1;
+        options.bracketException = exceptionsArrayOptions.indexOf("[]") !== -1;
+        options.parenException = exceptionsArrayOptions.indexOf("()") !== -1;
+        options.empty = exceptionsArrayOptions.indexOf("empty") !== -1;
     }
 
     /**
-     * Used with the `never` option to produce, given the exception options,
-     * two regular expressions to check for missing and rejected spaces.
+     * Produces an object with the opener and closer exception values
      * @param {Object} opts The exception options
-     * @returns {Object} `missingSpace` and `rejectedSpace` regular expressions
+     * @returns {Object} `openers` and `closers` exception values
      * @private
      */
-    function getNeverChecks(opts) {
-        var missingSpaceOpeners = [],
-            missingSpaceClosers = [],
-            rejectedSpaceOpeners = ["\\s"],
-            rejectedSpaceClosers = ["\\s"],
-            missingSpaceCheck,
-            rejectedSpaceCheck;
-
-        // Populate openers and closers
-        if (opts.braceException) {
-            missingSpaceOpeners.push("\\{");
-            missingSpaceClosers.push("\\}");
-            rejectedSpaceOpeners.push("\\{");
-            rejectedSpaceClosers.push("\\}");
-        }
-        if (opts.bracketException) {
-            missingSpaceOpeners.push("\\[");
-            missingSpaceClosers.push("\\]");
-            rejectedSpaceOpeners.push("\\[");
-            rejectedSpaceClosers.push("\\]");
-        }
-        if (opts.parenException) {
-            missingSpaceOpeners.push("\\(");
-            missingSpaceClosers.push("\\)");
-            rejectedSpaceOpeners.push("\\(");
-            rejectedSpaceClosers.push("\\)");
-        }
-        if (opts.empty) {
-            missingSpaceOpeners.push("\\)");
-            missingSpaceClosers.push("\\(");
-            rejectedSpaceOpeners.push("\\)");
-            rejectedSpaceClosers.push("\\(");
+    function getExceptions() {
+        var openers = [],
+            closers = [];
+        if (options.braceException) {
+            openers.push("{");
+            closers.push("}");
         }
 
-        if (missingSpaceOpeners.length) {
-            missingSpaceCheck = "\\((" + missingSpaceOpeners.join("|") + ")";
-            if (missingSpaceClosers.length) {
-                missingSpaceCheck += "|";
-            }
+        if (options.bracketException) {
+            openers.push("[");
+            closers.push("]");
         }
-        if (missingSpaceClosers.length) {
-            missingSpaceCheck += "(" + missingSpaceClosers.join("|") + ")\\)";
-        }
-
-        // compose the rejected regexp
-        rejectedSpaceCheck = "\\( +[^" + rejectedSpaceOpeners.join("") + "]";
-        rejectedSpaceCheck += "|[^" + rejectedSpaceClosers.join("") + "] +\\)";
 
-        return {
-            // e.g. \((\{)|(\})\) --- where {} is an exception
-            missingSpace: missingSpaceCheck || ".^",
-            // e.g. \( +[^ \n\r\{]|[^ \n\r\}] +\) --- where {} is an exception
-            rejectedSpace: rejectedSpaceCheck
-        };
-    }
-
-    /**
-     * Used with the `always` option to produce, given the exception options,
-     * two regular expressions to check for missing and rejected spaces.
-     * @param {Object} opts The exception options
-     * @returns {Object} `missingSpace` and `rejectedSpace` regular expressions
-     * @private
-     */
-    function getAlwaysChecks(opts) {
-        var missingSpaceOpeners = ["\\s", "\\)"],
-            missingSpaceClosers = ["\\s", "\\("],
-            rejectedSpaceOpeners = [],
-            rejectedSpaceClosers = [],
-            missingSpaceCheck,
-            rejectedSpaceCheck;
-
-        // Populate openers and closers
-        if (opts.braceException) {
-            missingSpaceOpeners.push("\\{");
-            missingSpaceClosers.push("\\}");
-            rejectedSpaceOpeners.push(" \\{");
-            rejectedSpaceClosers.push("\\} ");
-        }
-        if (opts.bracketException) {
-            missingSpaceOpeners.push("\\[");
-            missingSpaceClosers.push("\\]");
-            rejectedSpaceOpeners.push(" \\[");
-            rejectedSpaceClosers.push("\\] ");
+        if (options.parenException) {
+            openers.push("(");
+            closers.push(")");
         }
-        if (opts.parenException) {
-            missingSpaceOpeners.push("\\(");
-            missingSpaceClosers.push("\\)");
-            rejectedSpaceOpeners.push(" \\(");
-            rejectedSpaceClosers.push("\\) ");
-        }
-        if (opts.empty) {
-            rejectedSpaceOpeners.push(" \\)");
-            rejectedSpaceClosers.push("\\( ");
-        }
-
-        // compose the allowed regexp
-        missingSpaceCheck = "\\([^" + missingSpaceOpeners.join("") + "]";
-        missingSpaceCheck += "|[^" + missingSpaceClosers.join("") + "]\\)";
 
-        // compose the rejected regexp
-        if (rejectedSpaceOpeners.length) {
-            rejectedSpaceCheck = "\\((" + rejectedSpaceOpeners.join("|") + ")";
-            if (rejectedSpaceClosers.length) {
-                rejectedSpaceCheck += "|";
-            }
-        }
-        if (rejectedSpaceClosers.length) {
-            rejectedSpaceCheck += "(" + rejectedSpaceClosers.join("|") + ")\\)";
+        if (options.empty) {
+            openers.push(")");
+            closers.push("(");
         }
 
         return {
-            // e.g. \([^ \)\r\n\{]|[^ \(\r\n\}]\) --- where {} is an exception
-            missingSpace: missingSpaceCheck,
-            // e.g. \(( \{})|(\} )\) --- where {} is an excpetion
-            rejectedSpace: rejectedSpaceCheck || ".^"
+            openers: openers,
+            closers: closers
         };
     }
 
-    spaceChecks = (context.options[0] === "always") ? getAlwaysChecks(options) : getNeverChecks(options);
-    missingSpaceRegExp = new RegExp(spaceChecks.missingSpace, "mg");
-    rejectedSpaceRegExp = new RegExp(spaceChecks.rejectedSpace, "mg");
-
-
     //--------------------------------------------------------------------------
     // Helpers
     //--------------------------------------------------------------------------
-
-    var skipRanges = [];
+    var sourceCode = context.getSourceCode();
 
     /**
-     * Adds the range of a node to the set to be skipped when checking parens
-     * @param {ASTNode} node The node to skip
-     * @returns {void}
-     * @private
+     * Determines if a token is one of the exceptions for the opener paren
+     * @param {Object} token The token to check
+     * @returns {boolean} True if the token is one of the exceptions for the opener paren
      */
-    function addSkipRange(node) {
-        skipRanges.push(node.range);
+    function isOpenerException(token) {
+        return token.type === "Punctuator" && exceptions.openers.indexOf(token.value) >= 0;
     }
 
     /**
-     * Sorts the skipRanges array. Must be called before shouldSkip
-     * @returns {void}
-     * @private
+     * Determines if a token is one of the exceptions for the closer paren
+     * @param {Object} token The token to check
+     * @returns {boolean} True if the token is one of the exceptions for the closer paren
      */
-    function sortSkipRanges() {
-        skipRanges.sort(function(a, b) {
-            return a[0] - b[0];
-        });
+    function isCloserException(token) {
+        return token.type === "Punctuator" && exceptions.closers.indexOf(token.value) >= 0;
     }
 
     /**
-     * Checks if a certain position in the source should be skipped
-     * @param {Number} pos The 0-based index in the source
-     * @returns {boolean} whether the position should be skipped
-     * @private
+     * Determines if an opener paren should have a missing space after it
+     * @param {Object} left The paren token
+     * @param {Object} right The token after it
+     * @returns {boolean} True if the paren should have a space
      */
-    function shouldSkip(pos) {
-        var i, len, range;
-        for (i = 0, len = skipRanges.length; i < len; i += 1) {
-            range = skipRanges[i];
-            if (pos < range[0]) {
-                break;
-            } else if (pos < range[1]) {
-                return true;
+    function shouldOpenerHaveSpace(left, right) {
+        if (sourceCode.isSpaceBetweenTokens(left, right)) {
+            return false;
+        }
+
+        if (ALWAYS) {
+            if (right.type === "Punctuator" && right.value === ")") {
+                return false;
             }
+            return !isOpenerException(right);
+        } else {
+            return isOpenerException(right);
         }
-        return false;
     }
 
+    /**
+     * Determines if an closer paren should have a missing space after it
+     * @param {Object} left The token before the paren
+     * @param {Object} right The paren token
+     * @returns {boolean} True if the paren should have a space
+     */
+    function shouldCloserHaveSpace(left, right) {
+        if (left.type === "Punctuator" && left.value === "(") {
+            return false;
+        }
 
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    return {
+        if (sourceCode.isSpaceBetweenTokens(left, right)) {
+            return false;
+        }
 
-        "Program:exit": function checkParenSpaces(node) {
-
-            var nextMatch,
-                nextLine,
-                column,
-                line = 1,
-                source = context.getSource(),
-                pos = 0;
-
-            /**
-             * Check the match
-             * @param {object} match Object to match
-             * @param {string} message Message to report
-             * @returns {void}
-             * @private
-             */
-            function checkMatch(match, message) {
-                if (source.charAt(match.index) !== "(") {
-                    // Matched a closing paren pattern
-                    match.index += 1;
-                }
+        if (ALWAYS) {
+            return !isCloserException(left);
+        } else {
+            return isCloserException(left);
+        }
+    }
 
-                if (!shouldSkip(match.index)) {
-                    while ((nextLine = source.indexOf("\n", pos)) !== -1 && nextLine < match.index) {
-                        pos = nextLine + 1;
-                        line += 1;
-                    }
-                    column = match.index - pos;
+    /**
+     * Determines if an opener paren should not have an existing space after it
+     * @param {Object} left The paren token
+     * @param {Object} right The token after it
+     * @returns {boolean} True if the paren should reject the space
+     */
+    function shouldOpenerRejectSpace(left, right) {
+        if (!astUtils.isTokenOnSameLine(left, right)) {
+            return false;
+        }
 
-                    context.report(node, { line: line, column: column }, message);
-                }
-            }
+        if (!sourceCode.isSpaceBetweenTokens(left, right)) {
+            return false;
+        }
 
-            sortSkipRanges();
+        if (ALWAYS) {
+            return isOpenerException(right);
+        } else {
+            return !isOpenerException(right);
+        }
+    }
 
-            while ((nextMatch = rejectedSpaceRegExp.exec(source)) !== null) {
-                checkMatch(nextMatch, REJECTED_SPACE_MESSAGE);
-            }
+    /**
+     * Determines if an closer paren should not have an existing space after it
+     * @param {Object} left The token before the paren
+     * @param {Object} right The paren token
+     * @returns {boolean} True if the paren should reject the space
+     */
+    function shouldCloserRejectSpace(left, right) {
+        if (left.type === "Punctuator" && left.value === "(") {
+            return false;
+        }
 
-            while ((nextMatch = missingSpaceRegExp.exec(source)) !== null) {
-                checkMatch(nextMatch, MISSING_SPACE_MESSAGE);
-            }
+        if (!astUtils.isTokenOnSameLine(left, right)) {
+            return false;
+        }
 
-        },
+        if (!sourceCode.isSpaceBetweenTokens(left, right)) {
+            return false;
+        }
 
+        if (ALWAYS) {
+            return isCloserException(left);
+        } else {
+            return !isCloserException(left);
+        }
+    }
 
-        // These nodes can contain parentheses that this rule doesn't care about
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
 
-        LineComment: addSkipRange,
+    return {
+        "Program": function checkParenSpaces(node) {
+            var tokens = node.tokens;
+            var prevToken, nextToken;
+            exceptions = getExceptions();
 
-        BlockComment: addSkipRange,
+            tokens.forEach(function(token, i) {
+                prevToken = tokens[i - 1];
+                nextToken = tokens[i + 1];
 
-        Literal: addSkipRange,
+                if (token.type !== "Punctuator") {
+                    return;
+                }
 
-        TemplateElement: addSkipRange
+                if (token.value !== "(" && token.value !== ")") {
+                    return;
+                }
 
+                if (token.value === "(" && shouldOpenerHaveSpace(token, nextToken)) {
+                    context.report(node, token.loc.end, MISSING_SPACE_MESSAGE);
+                } else if (token.value === "(" && shouldOpenerRejectSpace(token, nextToken)) {
+                    context.report(node, token.loc.end, REJECTED_SPACE_MESSAGE);
+                } else if (token.value === ")" && shouldCloserHaveSpace(prevToken, token)) {
+                    context.report(node, token.loc.end, MISSING_SPACE_MESSAGE);
+                } else if (token.value === ")" && shouldCloserRejectSpace(prevToken, token)) {
+                    context.report(node, token.loc.end, REJECTED_SPACE_MESSAGE);
+                }
+            });
+        }
     };
 
 };