eslint 1.7.3 → 1.8.0

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)
         });
     }
 
@@ -165,7 +176,7 @@ module.exports = function(context) {
             });
 
             // 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.3",
+  "version": "1.8.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {