eslint 1.4.1 → 1.5.1

package/lib/rules/no-unused-vars.js

@@ -111,10 +111,10 @@ module.exports = function(context) {
      */
     function isUsedVariable(variable, references) {
         var functionNodes = variable.defs.filter(function(def) {
-            return def.type === "FunctionName";
-        }).map(function(def) {
-            return def.node;
-        }),
+                return def.type === "FunctionName";
+            }).map(function(def) {
+                return def.node;
+            }),
             isFunctionDefinition = functionNodes.length > 0;
 
         return references.some(function(ref) {

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

@@ -5,6 +5,8 @@
 
 "use strict";
 
+var astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -14,6 +16,7 @@ module.exports = function(context) {
     var configuration = context.options[0] || {},
         warningTerms = configuration.terms || ["todo", "fixme", "xxx"],
         location = configuration.location || "start",
+        selfConfigRegEx = /\bno-warning-comments\b/,
         warningRegExps;
 
     /**
@@ -69,6 +72,10 @@ module.exports = function(context) {
      * @returns {void} undefined.
      */
     function checkComment(node) {
+        if (astUtils.isDirectiveComment(node) && selfConfigRegEx.test(node.value)) {
+            return;
+        }
+
         var matches = commentContainsWarningTerm(node.value);
 
         matches.forEach(function(matchedTerm) {

package/lib/rules/object-curly-spacing.js

@@ -17,7 +17,8 @@ var astUtils = require("../ast-utils");
 //------------------------------------------------------------------------------
 
 module.exports = function(context) {
-    var spaced = context.options[0] === "always";
+    var spaced = context.options[0] === "always",
+        sourceCode = context.getSourceCode();
 
     /**
      * Determines whether an option is set, relative to the spacing option.
@@ -101,7 +102,7 @@ module.exports = function(context) {
             firstSpaced, lastSpaced;
 
         if (astUtils.isTokenOnSameLine(first, second)) {
-            firstSpaced = astUtils.isTokenSpaced(first, second);
+            firstSpaced = sourceCode.isSpaceBetweenTokens(first, second);
             if (options.spaced && !firstSpaced) {
                 reportRequiredBeginningSpace(node, first);
             }
@@ -111,7 +112,7 @@ module.exports = function(context) {
         }
 
         if (astUtils.isTokenOnSameLine(penultimate, last)) {
-            lastSpaced = astUtils.isTokenSpaced(penultimate, last);
+            lastSpaced = sourceCode.isSpaceBetweenTokens(penultimate, last);
             if (closingCurlyBraceMustBeSpaced && !lastSpaced) {
                 reportRequiredEndingSpace(node, last);
             }
@@ -131,8 +132,7 @@ module.exports = function(context) {
             return;
         }
 
-        var sourceCode = context.getSourceCode(),
-            first = sourceCode.getFirstToken(node),
+        var first = sourceCode.getFirstToken(node),
             last = sourceCode.getLastToken(node),
             second = sourceCode.getTokenAfter(first),
             penultimate = sourceCode.getTokenBefore(last);
@@ -150,8 +150,7 @@ module.exports = function(context) {
             return;
         }
 
-        var sourceCode = context.getSourceCode(),
-            firstSpecifier = node.specifiers[0],
+        var firstSpecifier = node.specifiers[0],
             lastSpecifier = node.specifiers[node.specifiers.length - 1];
 
         if (lastSpecifier.type !== "ImportSpecifier") {
@@ -185,8 +184,7 @@ module.exports = function(context) {
             return;
         }
 
-        var sourceCode = context.getSourceCode(),
-            firstSpecifier = node.specifiers[0],
+        var firstSpecifier = node.specifiers[0],
             lastSpecifier = node.specifiers[node.specifiers.length - 1],
             first = sourceCode.getTokenBefore(firstSpecifier),
             last = sourceCode.getTokenAfter(lastSpecifier);

package/lib/rules/semi-spacing.js

@@ -16,7 +16,8 @@ module.exports = function(context) {
 
     var config = context.options[0],
         requireSpaceBefore = false,
-        requireSpaceAfter = true;
+        requireSpaceAfter = true,
+        sourceCode = context.getSourceCode();
 
     if (typeof config === "object") {
         if (config.hasOwnProperty("before")) {
@@ -34,7 +35,7 @@ module.exports = function(context) {
      */
     function hasLeadingSpace(token) {
         var tokenBefore = context.getTokenBefore(token);
-        return tokenBefore && astUtils.isTokenOnSameLine(tokenBefore, token) && astUtils.isTokenSpaced(tokenBefore, token);
+        return tokenBefore && astUtils.isTokenOnSameLine(tokenBefore, token) && sourceCode.isSpaceBetweenTokens(tokenBefore, token);
     }
 
     /**
@@ -44,7 +45,7 @@ module.exports = function(context) {
      */
     function hasTrailingSpace(token) {
         var tokenAfter = context.getTokenAfter(token);
-        return tokenAfter && astUtils.isTokenOnSameLine(token, tokenAfter) && astUtils.isTokenSpaced(token, tokenAfter);
+        return tokenAfter && astUtils.isTokenOnSameLine(token, tokenAfter) && sourceCode.isSpaceBetweenTokens(token, tokenAfter);
     }
 
     /**
@@ -57,6 +58,30 @@ module.exports = function(context) {
         return !(tokenAfter && astUtils.isTokenOnSameLine(token, tokenAfter));
     }
 
+    /**
+     * Checks if the given token is the first token in its line
+     * @param {Token} token The token to check.
+     * @returns {boolean} Whether or not the token is the first in its line.
+     */
+    function isFirstTokenInCurrentLine(token) {
+        var tokenBefore = context.getTokenBefore(token);
+        return !(tokenBefore && astUtils.isTokenOnSameLine(token, tokenBefore));
+    }
+
+    /**
+     * Checks if the next token of a given token is a closing parenthesis.
+     * @param {Token} token The token to check.
+     * @returns {boolean} Whether or not the next token of a given token is a closing parenthesis.
+     */
+    function isBeforeClosingParen(token) {
+        var nextToken = context.getTokenAfter(token);
+        return (
+            nextToken &&
+            nextToken.type === "Punctuator" &&
+            (nextToken.value === "}" || nextToken.value === ")")
+        );
+    }
+
     /**
      * Checks if the given token is a semicolon.
      * @param {Token} token The token to check.
@@ -88,7 +113,7 @@ module.exports = function(context) {
                 }
             }
 
-            if (!isLastTokenInCurrentLine(token)) {
+            if (!isFirstTokenInCurrentLine(token) && !isLastTokenInCurrentLine(token) && !isBeforeClosingParen(token)) {
                 if (hasTrailingSpace(token)) {
                     if (!requireSpaceAfter) {
                         context.report(node, location, "Unexpected whitespace after semicolon.");

package/lib/rules/space-after-keywords.js

@@ -31,13 +31,35 @@ module.exports = function(context) {
             value = left.value;
 
         if (hasSpace !== requiresSpace) {
-            context.report(node, "Keyword \"{{value}}\" must {{not}}be followed by whitespace.", {
-                value: value,
-                not: requiresSpace ? "" : "not "
+            context.report({
+                node: node,
+                message: "Keyword \"{{value}}\" must {{not}}be followed by whitespace.",
+                data: {
+                    value: value,
+                    not: requiresSpace ? "" : "not "
+                },
+                fix: function(fixer) {
+                    if (requiresSpace) {
+                        return fixer.insertTextAfter(left, " ");
+                    } else {
+                        return fixer.removeRange([left.range[1], right.range[0]]);
+                    }
+                }
             });
         } else if (left.loc.end.line !== right.loc.start.line) {
-            context.report(node, "Keyword \"{{value}}\" must not be followed by a newline.", {
-                value: value
+            context.report({
+                node: node,
+                message: "Keyword \"{{value}}\" must not be followed by a newline.",
+                data: {
+                    value: value
+                },
+                fix: function(fixer) {
+                    var text = "";
+                    if (requiresSpace) {
+                        text = " ";
+                    }
+                    return fixer.replaceTextRange([left.range[1], right.range[0]], text);
+                }
             });
         }
     }

package/lib/rules/space-before-blocks.js

@@ -13,7 +13,28 @@ var astUtils = require("../ast-utils");
 //------------------------------------------------------------------------------
 
 module.exports = function(context) {
-    var requireSpace = context.options[0] !== "never";
+    var config = context.options[0],
+        sourceCode = context.getSourceCode(),
+        checkFunctions = true,
+        checkKeywords = true;
+
+    if (typeof config === "object") {
+        checkFunctions = config.functions !== "never";
+        checkKeywords = config.keywords !== "never";
+    } else if (config === "never") {
+        checkFunctions = false;
+        checkKeywords = false;
+    }
+
+    /**
+     * Checks whether or not a given token is an arrow operator (=>).
+     *
+     * @param {Token} token - A token to check.
+     * @returns {boolean} `true` if the token is an arrow operator.
+     */
+    function isArrow(token) {
+        return token.type === "Punctuator" && token.value === "=>";
+    }
 
     /**
      * Checks the given BlockStatement node has a preceding space if it doesn’t start on a new line.
@@ -22,18 +43,38 @@ module.exports = function(context) {
      */
     function checkPrecedingSpace(node) {
         var precedingToken = context.getTokenBefore(node),
-            hasSpace;
+            hasSpace,
+            parent,
+            requireSpace;
 
-        if (precedingToken && astUtils.isTokenOnSameLine(precedingToken, node)) {
-            hasSpace = astUtils.isTokenSpaced(precedingToken, node);
+        if (precedingToken && !isArrow(precedingToken) && astUtils.isTokenOnSameLine(precedingToken, node)) {
+            hasSpace = sourceCode.isSpaceBetweenTokens(precedingToken, node);
+            parent = context.getAncestors().pop();
+            if (parent.type === "FunctionExpression" || parent.type === "FunctionDeclaration") {
+                requireSpace = checkFunctions;
+            } else {
+                requireSpace = checkKeywords;
+            }
 
             if (requireSpace) {
                 if (!hasSpace) {
-                    context.report(node, "Missing space before opening brace.");
+                    context.report({
+                        node: node,
+                        message: "Missing space before opening brace.",
+                        fix: function(fixer) {
+                            return fixer.insertTextBefore(node, " ");
+                        }
+                    });
                 }
             } else {
                 if (hasSpace) {
-                    context.report(node, "Unexpected space before opening brace.");
+                    context.report({
+                        node: node,
+                        message: "Unexpected space before opening brace.",
+                        fix: function(fixer) {
+                            return fixer.removeRange([precedingToken.range[1], node.range[0]]);
+                        }
+                    });
                 }
             }
         }
@@ -69,6 +110,22 @@ module.exports = function(context) {
 
 module.exports.schema = [
     {
-        "enum": ["always", "never"]
+        "oneOf": [
+            {
+                "enum": ["always", "never"]
+            },
+            {
+                "type": "object",
+                "properties": {
+                    "keywords": {
+                        "enum": ["always", "never"]
+                    },
+                    "functions": {
+                        "enum": ["always", "never"]
+                    }
+                },
+                "additionalProperties": false
+            }
+        ]
     }
 ];

package/lib/rules/space-before-function-paren.js

@@ -2,6 +2,7 @@
  * @fileoverview Rule to validate spacing before function paren.
  * @author Mathias Schreck <https://github.com/lo1tuma>
  * @copyright 2015 Mathias Schreck
+ * See LICENSE in root directory for full license.
  */
 "use strict";
 
@@ -12,6 +13,7 @@
 module.exports = function(context) {
 
     var configuration = context.options[0],
+        sourceCode = context.getSourceCode(),
         requireAnonymousFunctionSpacing = true,
         requireNamedFunctionSpacing = true;
 
@@ -23,16 +25,6 @@ module.exports = function(context) {
         requireNamedFunctionSpacing = false;
     }
 
-    /**
-     * Determines whether two adjacent tokens are have whitespace between them.
-     * @param {Object} left - The left token object.
-     * @param {Object} right - The right token object.
-     * @returns {boolean} Whether or not there is space between the tokens.
-     */
-    function isSpaced(left, right) {
-        return left.range[1] < right.range[0];
-    }
-
     /**
      * Determines whether a function has a name.
      * @param {ASTNode} node The function node.
@@ -99,13 +91,27 @@ module.exports = function(context) {
 
         location = leftToken.loc.end;
 
-        if (isSpaced(leftToken, rightToken)) {
+        if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken)) {
             if ((isNamed && !requireNamedFunctionSpacing) || (!isNamed && !requireAnonymousFunctionSpacing)) {
-                context.report(node, location, "Unexpected space before function parentheses.");
+                context.report({
+                    node: node,
+                    loc: location,
+                    message: "Unexpected space before function parentheses.",
+                    fix: function(fixer) {
+                        return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
+                    }
+                });
             }
         } else {
             if ((isNamed && requireNamedFunctionSpacing) || (!isNamed && requireAnonymousFunctionSpacing)) {
-                context.report(node, location, "Missing space before function parentheses.");
+                context.report({
+                    node: node,
+                    loc: location,
+                    message: "Missing space before function parentheses.",
+                    fix: function(fixer) {
+                        return fixer.insertTextAfter(leftToken, " ");
+                    }
+                });
             }
         }
     }

package/lib/rules/space-before-keywords.js

@@ -17,12 +17,37 @@ var ERROR_MSG_NO_SPACE_EXPECTED = "Unexpected space before keyword \"{{keyword}}
 
 module.exports = function(context) {
 
+    var sourceCode = context.getSourceCode();
+
     var SPACE_REQUIRED = context.options[0] !== "never";
 
     //--------------------------------------------------------------------------
     // Helpers
     //--------------------------------------------------------------------------
 
+    /**
+     * Report the error message
+     * @param {ASTNode} node node to report
+     * @param {string} message Error message to be displayed
+     * @param {object} data Data object for the rule message
+     * @returns {void}
+     */
+    function report(node, message, data) {
+        context.report({
+            node: node,
+            message: message,
+            data: data,
+            fix: function(fixer) {
+                if (SPACE_REQUIRED) {
+                    return fixer.insertTextBefore(node, " ");
+                } else {
+                    var tokenBefore = context.getTokenBefore(node);
+                    return fixer.removeRange([tokenBefore.range[1], node.range[0]]);
+                }
+            }
+        });
+    }
+
     /**
      * Check if a token meets the criteria
      *
@@ -47,10 +72,10 @@ module.exports = function(context) {
         }
 
         options = options || {};
-        options.allowedPrecedingChars = options.allowedPrecedingChars || [];
+        options.allowedPrecedingChars = options.allowedPrecedingChars || [ "{" ];
         options.requireSpace = typeof options.requireSpace === "undefined" ? SPACE_REQUIRED : options.requireSpace;
 
-        var hasSpace = astUtils.isTokenSpaced(left, right);
+        var hasSpace = sourceCode.isSpaceBetweenTokens(left, right);
         var spaceOk = hasSpace === options.requireSpace;
 
         if (spaceOk) {
@@ -59,13 +84,13 @@ module.exports = function(context) {
 
         if (!astUtils.isTokenOnSameLine(left, right)) {
             if (!options.requireSpace) {
-                context.report(node, ERROR_MSG_NO_SPACE_EXPECTED, { keyword: right.value });
+                report(node, ERROR_MSG_NO_SPACE_EXPECTED, { keyword: right.value });
             }
             return;
         }
 
         if (!options.requireSpace) {
-            context.report(node, ERROR_MSG_NO_SPACE_EXPECTED, { keyword: right.value });
+            report(node, ERROR_MSG_NO_SPACE_EXPECTED, { keyword: right.value });
             return;
         }
 
@@ -73,7 +98,7 @@ module.exports = function(context) {
             return;
         }
 
-        context.report(node, ERROR_MSG_SPACE_EXPECTED, { keyword: right.value });
+        report(node, ERROR_MSG_SPACE_EXPECTED, { keyword: right.value });
 
     }
 
@@ -130,7 +155,7 @@ module.exports = function(context) {
                 check(caseNode);
             });
         },
-        ThrowStatement: check,
+        "ThrowStatement": check,
         "TryStatement": function(node) {
             // try
             check(node);
@@ -144,7 +169,7 @@ module.exports = function(context) {
         },
         "WithStatement": check,
         "VariableDeclaration": function(node) {
-            check(node, { allowedPrecedingChars: [ "(" ] });
+            check(node, { allowedPrecedingChars: [ "(", "{" ] });
         },
         "ReturnStatement": check,
         "BreakStatement": check,
@@ -152,25 +177,28 @@ module.exports = function(context) {
         "ContinueStatement": check,
         "FunctionDeclaration": check,
         "FunctionExpression": function(node) {
-
             var left = context.getTokenBefore(node);
-            var right = null;
+            var right = context.getFirstToken(node);
 
-            if (left.type === "Identifier") {
-                right = left;
-                left = context.getTokenBefore(node, 1);
-            } else {
-                right = context.getFirstToken(node);
+            // If it's a method, a getter, or a setter, the first token is not the `function` keyword.
+            if (right.type !== "Keyword") {
+                return;
             }
 
-            checkTokens(node, left, right, { allowedPrecedingChars: [ "(" ] });
+            checkTokens(node, left, right, { allowedPrecedingChars: [ "(", "{" ] });
         },
         "YieldExpression": function(node) {
-            check(node, { allowedPrecedingChars: [ "(" ] });
+            check(node, { allowedPrecedingChars: [ "(", "{" ] });
         },
         "ForOfStatement": check,
         "ClassBody": function(node) {
-            check(context.getTokenBefore(node, 1));
+
+            // Find the 'class' token
+            while (node.value !== "class") {
+                node = context.getTokenBefore(node);
+            }
+
+            check(node);
         },
         "Super": check
 

package/lib/rules/space-infix-ops.js

@@ -48,7 +48,28 @@ module.exports = function(context) {
      * @private
      */
     function report(mainNode, culpritToken) {
-        context.report(mainNode, culpritToken.loc.start, "Infix operators must be spaced.");
+        context.report({
+            node: mainNode,
+            loc: culpritToken.loc.start,
+            message: "Infix operators must be spaced.",
+            fix: function(fixer) {
+                var previousToken = context.getTokenBefore(culpritToken);
+                var afterToken = context.getTokenAfter(culpritToken);
+                var fixString = "";
+
+                if (culpritToken.range[0] - previousToken.range[1] === 0) {
+                    fixString = " ";
+                }
+
+                fixString += culpritToken.value;
+
+                if (afterToken.range[0] - culpritToken.range[1] === 0) {
+                    fixString += " ";
+                }
+
+                return fixer.replaceText(culpritToken, fixString);
+            }
+        });
     }
 
     /**

package/lib/rules/space-return-throw-case.js

@@ -21,7 +21,13 @@ module.exports = function(context) {
             value = tokens[0].value;
 
         if (tokens[0].range[1] >= tokens[1].range[0]) {
-            context.report(node, "Keyword \"" + value + "\" must be followed by whitespace.");
+            context.report({
+                node: node,
+                message: "Keyword \"" + value + "\" must be followed by whitespace.",
+                fix: function(fixer) {
+                    return fixer.insertTextAfterRange(tokens[0].range, " ");
+                }
+            });
         }
     }
 

package/lib/testers/event-generator-tester.js

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Helpers to test EventGenerator interface.
+ * @author Toru Nagashima
+ * @copyright 2015 Toru Nagashima. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+"use strict";
+
+/* global describe, it */
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var assert = require("assert");
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+    /**
+     * Overrideable `describe` function to test.
+     * @param {string} text - A description.
+     * @param {function} method - A test logic.
+     * @returns {any} The returned value with the test logic.
+     */
+    describe: (typeof describe === "function") ? describe : function(text, method) {
+        return method.apply(this);
+    },
+
+    /**
+     * Overrideable `it` function to test.
+     * @param {string} text - A description.
+     * @param {function} method - A test logic.
+     * @returns {any} The returned value with the test logic.
+     */
+    it: (typeof it === "function") ? it : function(text, method) {
+        return method.apply(this);
+    },
+
+    /**
+     * Does some tests to check a given object implements the EventGenerator interface.
+     * @param {object} instance - An object to check.
+     * @returns {void}
+     */
+    testEventGeneratorInterface: function(instance) {
+        this.describe("should implement EventGenerator interface", function() {
+            this.it("should have `emitter` property.", function() {
+                assert.equal(typeof instance.emitter, "object");
+                assert.equal(typeof instance.emitter.emit, "function");
+            });
+
+            this.it("should have `enterNode` property.", function() {
+                assert.equal(typeof instance.enterNode, "function");
+            });
+
+            this.it("should have `leaveNode` property.", function() {
+                assert.equal(typeof instance.leaveNode, "function");
+            });
+        }.bind(this));
+    }
+};