eslint 1.7.1 → 1.9.0

package/lib/rules/space-in-parens.js

@@ -6,6 +6,8 @@
  */
 "use strict";
 
+var astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -14,258 +16,205 @@ 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
-    //--------------------------------------------------------------------------
+        if (sourceCode.isSpaceBetweenTokens(left, right)) {
+            return false;
+        }
 
-    return {
+        if (ALWAYS) {
+            return !isCloserException(left);
+        } else {
+            return isCloserException(left);
+        }
+    }
 
-        "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;
-                }
+    /**
+     * 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 (right.type === "Line") {
+            return false;
+        }
 
-                if (!shouldSkip(match.index)) {
-                    while ((nextLine = source.indexOf("\n", pos)) !== -1 && nextLine < match.index) {
-                        pos = nextLine + 1;
-                        line += 1;
-                    }
-                    column = match.index - pos;
+        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, prevToken, nextToken;
+            exceptions = getExceptions();
+            tokens = sourceCode.tokensAndComments;
 
-        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);
+                }
+            });
+        }
     };
 
 };

package/lib/rules/spaced-comment.js

@@ -165,16 +165,16 @@ module.exports = function(context) {
         if (requireSpace) {
             if (!rule.regex.test(node.value)) {
                 if (rule.hasExceptions) {
-                    context.report(node, "Expected exception block, space or tab after " + commentIdentifier + " in comment.");
+                    context.report(node, "Expected exception block, space or tab after \"" + commentIdentifier + "\" in comment.");
                 } else {
-                    context.report(node, "Expected space or tab after " + commentIdentifier + " in comment.");
+                    context.report(node, "Expected space or tab after \"" + commentIdentifier + "\" in comment.");
                 }
             }
         } else {
             var matched = rule.regex.exec(node.value);
             if (matched) {
                 if (!matched[1]) {
-                    context.report(node, "Unexpected space or tab after " + commentIdentifier + " in comment.");
+                    context.report(node, "Unexpected space or tab after \"" + commentIdentifier + "\" in comment.");
                 } else {
                     context.report(node, "Unexpected space or tab after marker (" + matched[1] + ") in comment.");
                 }

package/lib/rules/valid-jsdoc.js

@@ -33,6 +33,16 @@ module.exports = function(context) {
     // Using a stack to store if a function returns or not (handling nested functions)
     var fns = [];
 
+    /**
+     * Check if node type is a Class
+     * @param {ASTNode} node node to check.
+     * @returns {boolean} True is its a class
+     * @private
+     */
+    function isTypeClass(node) {
+        return node.type === "ClassExpression" || node.type === "ClassDeclaration";
+    }
+
     /**
      * When parsing a new function, store it in our function stack.
      * @param {ASTNode} node A function node to check.
@@ -41,7 +51,8 @@ module.exports = function(context) {
      */
     function startFunction(node) {
         fns.push({
-            returnPresent: (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement")
+            returnPresent: (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") ||
+                isTypeClass(node)
         });
     }
 
@@ -158,14 +169,14 @@ module.exports = function(context) {
                 }
 
                 // check tag preferences
-                if (prefer.hasOwnProperty(tag.title)) {
+                if (prefer.hasOwnProperty(tag.title) && tag.title !== prefer[tag.title]) {
                     context.report(jsdocNode, "Use @{{name}} instead.", { name: prefer[tag.title] });
                 }
 
             });
 
             // check for functions missing @returns
-            if (!isOverride && !hasReturns && !hasConstructor && node.parent.kind !== "get") {
+            if (!isOverride && !hasReturns && !hasConstructor && node.parent.kind !== "get" && !isTypeClass(node)) {
                 if (requireReturn || functionData.returnPresent) {
                     context.report(jsdocNode, "Missing JSDoc @" + (prefer.returns || "returns") + " for function.");
                 }
@@ -174,23 +185,25 @@ module.exports = function(context) {
             // check the parameters
             var jsdocParams = Object.keys(params);
 
-            node.params.forEach(function(param, i) {
-                var name = param.name;
-
-                // TODO(nzakas): Figure out logical things to do with destructured, default, rest params
-                if (param.type === "Identifier") {
-                    if (jsdocParams[i] && (name !== jsdocParams[i])) {
-                        context.report(jsdocNode, "Expected JSDoc for '{{name}}' but found '{{jsdocName}}'.", {
-                            name: name,
-                            jsdocName: jsdocParams[i]
-                        });
-                    } else if (!params[name] && !isOverride) {
-                        context.report(jsdocNode, "Missing JSDoc for parameter '{{name}}'.", {
-                            name: name
-                        });
+            if (node.params) {
+                node.params.forEach(function(param, i) {
+                    var name = param.name;
+
+                    // TODO(nzakas): Figure out logical things to do with destructured, default, rest params
+                    if (param.type === "Identifier") {
+                        if (jsdocParams[i] && (name !== jsdocParams[i])) {
+                            context.report(jsdocNode, "Expected JSDoc for '{{name}}' but found '{{jsdocName}}'.", {
+                                name: name,
+                                jsdocName: jsdocParams[i]
+                            });
+                        } else if (!params[name] && !isOverride) {
+                            context.report(jsdocNode, "Missing JSDoc for parameter '{{name}}'.", {
+                                name: name
+                            });
+                        }
                     }
-                }
-            });
+                });
+            }
 
             if (options.matchDescription) {
                 var regex = new RegExp(options.matchDescription);
@@ -212,9 +225,13 @@ module.exports = function(context) {
         "ArrowFunctionExpression": startFunction,
         "FunctionExpression": startFunction,
         "FunctionDeclaration": startFunction,
+        "ClassExpression": startFunction,
+        "ClassDeclaration": startFunction,
         "ArrowFunctionExpression:exit": checkJSDoc,
         "FunctionExpression:exit": checkJSDoc,
         "FunctionDeclaration:exit": checkJSDoc,
+        "ClassExpression:exit": checkJSDoc,
+        "ClassDeclaration:exit": checkJSDoc,
         "ReturnStatement": addReturn
     };
 

package/lib/rules.js

@@ -31,8 +31,6 @@ function define(ruleId, ruleModule) {
     rules[ruleId] = ruleModule;
 }
 
-exports.define = define;
-
 /**
  * Loads and registers all rules from passed rules directory.
  * @param {String} [rulesDir] Path to rules directory, may be relative. Defaults to `lib/rules`.
@@ -45,43 +43,49 @@ function load(rulesDir) {
     });
 }
 
-exports.load = load;
-
 /**
  * Registers all given rules of a plugin.
  * @param {Object} pluginRules A key/value map of rule definitions.
  * @param {String} pluginName The name of the plugin without prefix (`eslint-plugin-`).
  * @returns {void}
  */
-exports.import = function(pluginRules, pluginName) {
+function importPlugin(pluginRules, pluginName) {
     Object.keys(pluginRules).forEach(function(ruleId) {
         var qualifiedRuleId = pluginName + "/" + ruleId,
             rule = pluginRules[ruleId];
 
         define(qualifiedRuleId, rule);
     });
-};
+}
 
 /**
  * Access rule handler by id (file name).
  * @param {String} ruleId Rule id (file name).
  * @returns {Function} Rule handler.
  */
-exports.get = function(ruleId) {
+function get(ruleId) {
     if (typeof rules[ruleId] === "string") {
         return require(rules[ruleId]);
     } else {
         return rules[ruleId];
     }
-};
+}
 
 /**
  * Reset rules storage.
  * Should be used only in tests.
  * @returns {void}
  */
-exports.testClear = function() {
+function testClear() {
     rules = Object.create(null);
+}
+
+module.exports = {
+    define: define,
+    load: load,
+    import: importPlugin,
+    get: get,
+    testClear: testClear
 };
 
 //------------------------------------------------------------------------------