eslint 1.7.0 → 1.8.0

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);
+                }
+            });
+        }
     };
 
 };

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/testers/rule-tester.js

@@ -78,6 +78,34 @@ var RuleTesterParameters = [
 
 var validateSchema = validate(metaSchema, { verbose: true });
 
+var hasOwnProperty = Function.call.bind(Object.hasOwnProperty);
+
+/**
+ * Clones a given value deeply.
+ * Note: This ignores `parent` property.
+ *
+ * @param {any} x - A value to clone.
+ * @returns {any} A cloned value.
+ */
+function cloneDeeplyExcludesParent(x) {
+    if (typeof x === "object" && x !== null) {
+        if (Array.isArray(x)) {
+            return x.map(cloneDeeplyExcludesParent);
+        }
+
+        var retv = {};
+        for (var key in x) {
+            if (key !== "parent" && hasOwnProperty(x, key)) {
+                retv[key] = cloneDeeplyExcludesParent(x[key]);
+            }
+        }
+
+        return retv;
+    }
+
+    return x;
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -178,7 +206,7 @@ RuleTester.prototype = {
          */
         function runRuleForItem(ruleName, item) {
             var config = clone(testerConfig),
-                code, filename, schema;
+                code, filename, schema, beforeAST, afterAST;
 
             if (typeof item === "string") {
                 code = item;
@@ -223,7 +251,21 @@ RuleTester.prototype = {
 
             validator.validate(config, "rule-tester");
 
-            return eslint.verify(code, config, filename);
+            // To cache AST.
+            eslint.reset();
+            eslint.on("Program", function(node) {
+                beforeAST = cloneDeeplyExcludesParent(node);
+
+                eslint.on("Program:exit", function(node) {
+                    afterAST = cloneDeeplyExcludesParent(node);
+                });
+            });
+
+            return {
+                messages: eslint.verify(code, config, filename, true),
+                beforeAST: beforeAST,
+                afterAST: afterAST
+            };
         }
 
         /**
@@ -235,10 +277,17 @@ RuleTester.prototype = {
          * @private
          */
         function testValidTemplate(ruleName, item) {
-            var messages = runRuleForItem(ruleName, item);
+            var result = runRuleForItem(ruleName, item);
+            var messages = result.messages;
 
             assert.equal(messages.length, 0, util.format("Should have no errors but had %d: %s",
                         messages.length, util.inspect(messages)));
+
+            assert.deepEqual(
+                result.beforeAST,
+                result.afterAST,
+                "Rule should not modify AST."
+            );
         }
 
         /**
@@ -250,7 +299,8 @@ RuleTester.prototype = {
          * @private
          */
         function testInvalidTemplate(ruleName, item) {
-            var messages = runRuleForItem(ruleName, item);
+            var result = runRuleForItem(ruleName, item);
+            var messages = result.messages;
 
             if (typeof item.errors === "number") {
                 assert.equal(messages.length, item.errors, util.format("Should have %d errors but had %d: %s",
@@ -261,11 +311,10 @@ RuleTester.prototype = {
                     item.errors.length, messages.length, util.inspect(messages)));
 
                 if (item.hasOwnProperty("output")) {
-                    var result = SourceCodeFixer.applyFixes(eslint.getSourceCode(), messages);
-                    assert.equal(result.output, item.output, "Output is incorrect.");
+                    var fixResult = SourceCodeFixer.applyFixes(eslint.getSourceCode(), messages);
+                    assert.equal(fixResult.output, item.output, "Output is incorrect.");
                 }
 
-
                 for (var i = 0, l = item.errors.length; i < l; i++) {
                     assert.ok(!("fatal" in messages[i]), "A fatal parsing error occurred: " + messages[i].message);
                     assert.equal(messages[i].ruleId, ruleName, "Error rule name should be the same as the name of the rule being tested");
@@ -299,6 +348,12 @@ RuleTester.prototype = {
                     }
                 }
             }
+
+            assert.deepEqual(
+                result.beforeAST,
+                result.afterAST,
+                "Rule should not modify AST."
+            );
         }
 
         // this creates a mocha test suite and pipes all supplied info

package/lib/util/source-code.js

@@ -211,6 +211,12 @@ SourceCode.prototype = {
                 }
                 break;
 
+            case "ClassDeclaration":
+                return findJSDocComment(node.leadingComments, line);
+
+            case "ClassExpression":
+                return findJSDocComment(parent.parent.leadingComments, line);
+
             case "ArrowFunctionExpression":
             case "FunctionExpression":
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {