eslint 0.22.0 → 0.24.1

package/lib/rules/semi-spacing.js

@@ -1,167 +1,167 @@
-/**
- * @fileoverview Validates spacing before and after semicolon
- * @author Mathias Schreck
- * @copyright 2015 Mathias Schreck
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function (context) {
-
-    var config = context.options[0],
-        requireSpaceBefore = false,
-        requireSpaceAfter = true;
-
-    if (typeof config === "object") {
-        if (config.hasOwnProperty("before")) {
-            requireSpaceBefore = config.before;
-        }
-        if (config.hasOwnProperty("after")) {
-            requireSpaceAfter = config.after;
-        }
-    }
-
-    /**
-     * Determines whether two adjacent tokens 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];
-    }
-
-    /**
-     * Checks whether two tokens are on the same line.
-     * @param {Object} left The leftmost token.
-     * @param {Object} right The rightmost token.
-     * @returns {boolean} True if the tokens are on the same line, false if not.
-     * @private
-     */
-    function isSameLine(left, right) {
-        return left.loc.end.line === right.loc.start.line;
-    }
-
-    /**
-     * Checks if a given token has leading whitespace.
-     * @param {Object} token The token to check.
-     * @returns {boolean} True if the given token has leading space, false if not.
-     */
-    function hasLeadingSpace(token) {
-        var tokenBefore = context.getTokenBefore(token);
-        return tokenBefore && isSameLine(tokenBefore, token) && isSpaced(tokenBefore, token);
-    }
-
-    /**
-     * Checks if a given token has trailing whitespace.
-     * @param {Object} token The token to check.
-     * @returns {boolean} True if the given token has trailing space, false if not.
-     */
-    function hasTrailingSpace(token) {
-        var tokenAfter = context.getTokenAfter(token);
-        return tokenAfter && isSameLine(token, tokenAfter) && isSpaced(token, tokenAfter);
-    }
-
-    /**
-     * Checks if the given token is the last token in its line.
-     * @param {Token} token The token to check.
-     * @returns {boolean} Whether or not the token is the last in its line.
-     */
-    function isLastTokenInCurrentLine(token) {
-        var tokenAfter = context.getTokenAfter(token);
-        return !(tokenAfter && isSameLine(token, tokenAfter));
-    }
-
-    /**
-     * Checks if the given token is a semicolon.
-     * @param {Token} token The token to check.
-     * @returns {boolean} Whether or not the given token is a semicolon.
-     */
-    function isSemicolon(token) {
-        return token.type === "Punctuator" && token.value === ";";
-    }
-
-    /**
-     * Reports if the given token has invalid spacing.
-     * @param {Token} token The semicolon token to check.
-     * @param {ASTNode} node The corresponding node of the token.
-     * @returns {void}
-     */
-    function checkSemicolonSpacing(token, node) {
-        var location;
-
-        if (isSemicolon(token)) {
-            location = token.loc.start;
-
-            if (hasLeadingSpace(token)) {
-                if (!requireSpaceBefore) {
-                    context.report(node, location, "Unexpected whitespace before semicolon.");
-                }
-            } else {
-                if (requireSpaceBefore) {
-                    context.report(node, location, "Missing whitespace before semicolon.");
-                }
-            }
-
-            if (!isLastTokenInCurrentLine(token)) {
-                if (hasTrailingSpace(token)) {
-                    if (!requireSpaceAfter) {
-                        context.report(node, location, "Unexpected whitespace after semicolon.");
-                    }
-                } else {
-                    if (requireSpaceAfter) {
-                        context.report(node, location, "Missing whitespace after semicolon.");
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Checks the spacing of the semicolon with the assumption that the last token is the semicolon.
-     * @param {ASTNode} node The node to check.
-     * @returns {void}
-     */
-    function checkNode(node) {
-        var token = context.getLastToken(node);
-        checkSemicolonSpacing(token, node);
-    }
-
-    return {
-        "VariableDeclaration": checkNode,
-        "ExpressionStatement": checkNode,
-        "BreakStatement": checkNode,
-        "ContinueStatement": checkNode,
-        "DebuggerStatement": checkNode,
-        "ReturnStatement": checkNode,
-        "ThrowStatement": checkNode,
-        "ForStatement": function (node) {
-            if (node.init) {
-                checkSemicolonSpacing(context.getTokenAfter(node.init), node);
-            }
-
-            if (node.test) {
-                checkSemicolonSpacing(context.getTokenAfter(node.test), node);
-            }
-        }
-    };
-};
-
-module.exports.schema = [
-    {
-        "type": "object",
-        "properties": {
-            "before": {
-                "type": "boolean"
-            },
-            "after": {
-                "type": "boolean"
-            }
-        },
-        "additionalProperties": false
-    }
-];
+/**
+ * @fileoverview Validates spacing before and after semicolon
+ * @author Mathias Schreck
+ * @copyright 2015 Mathias Schreck
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function (context) {
+
+    var config = context.options[0],
+        requireSpaceBefore = false,
+        requireSpaceAfter = true;
+
+    if (typeof config === "object") {
+        if (config.hasOwnProperty("before")) {
+            requireSpaceBefore = config.before;
+        }
+        if (config.hasOwnProperty("after")) {
+            requireSpaceAfter = config.after;
+        }
+    }
+
+    /**
+     * Determines whether two adjacent tokens 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];
+    }
+
+    /**
+     * Checks whether two tokens are on the same line.
+     * @param {Object} left The leftmost token.
+     * @param {Object} right The rightmost token.
+     * @returns {boolean} True if the tokens are on the same line, false if not.
+     * @private
+     */
+    function isSameLine(left, right) {
+        return left.loc.end.line === right.loc.start.line;
+    }
+
+    /**
+     * Checks if a given token has leading whitespace.
+     * @param {Object} token The token to check.
+     * @returns {boolean} True if the given token has leading space, false if not.
+     */
+    function hasLeadingSpace(token) {
+        var tokenBefore = context.getTokenBefore(token);
+        return tokenBefore && isSameLine(tokenBefore, token) && isSpaced(tokenBefore, token);
+    }
+
+    /**
+     * Checks if a given token has trailing whitespace.
+     * @param {Object} token The token to check.
+     * @returns {boolean} True if the given token has trailing space, false if not.
+     */
+    function hasTrailingSpace(token) {
+        var tokenAfter = context.getTokenAfter(token);
+        return tokenAfter && isSameLine(token, tokenAfter) && isSpaced(token, tokenAfter);
+    }
+
+    /**
+     * Checks if the given token is the last token in its line.
+     * @param {Token} token The token to check.
+     * @returns {boolean} Whether or not the token is the last in its line.
+     */
+    function isLastTokenInCurrentLine(token) {
+        var tokenAfter = context.getTokenAfter(token);
+        return !(tokenAfter && isSameLine(token, tokenAfter));
+    }
+
+    /**
+     * Checks if the given token is a semicolon.
+     * @param {Token} token The token to check.
+     * @returns {boolean} Whether or not the given token is a semicolon.
+     */
+    function isSemicolon(token) {
+        return token.type === "Punctuator" && token.value === ";";
+    }
+
+    /**
+     * Reports if the given token has invalid spacing.
+     * @param {Token} token The semicolon token to check.
+     * @param {ASTNode} node The corresponding node of the token.
+     * @returns {void}
+     */
+    function checkSemicolonSpacing(token, node) {
+        var location;
+
+        if (isSemicolon(token)) {
+            location = token.loc.start;
+
+            if (hasLeadingSpace(token)) {
+                if (!requireSpaceBefore) {
+                    context.report(node, location, "Unexpected whitespace before semicolon.");
+                }
+            } else {
+                if (requireSpaceBefore) {
+                    context.report(node, location, "Missing whitespace before semicolon.");
+                }
+            }
+
+            if (!isLastTokenInCurrentLine(token)) {
+                if (hasTrailingSpace(token)) {
+                    if (!requireSpaceAfter) {
+                        context.report(node, location, "Unexpected whitespace after semicolon.");
+                    }
+                } else {
+                    if (requireSpaceAfter) {
+                        context.report(node, location, "Missing whitespace after semicolon.");
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Checks the spacing of the semicolon with the assumption that the last token is the semicolon.
+     * @param {ASTNode} node The node to check.
+     * @returns {void}
+     */
+    function checkNode(node) {
+        var token = context.getLastToken(node);
+        checkSemicolonSpacing(token, node);
+    }
+
+    return {
+        "VariableDeclaration": checkNode,
+        "ExpressionStatement": checkNode,
+        "BreakStatement": checkNode,
+        "ContinueStatement": checkNode,
+        "DebuggerStatement": checkNode,
+        "ReturnStatement": checkNode,
+        "ThrowStatement": checkNode,
+        "ForStatement": function (node) {
+            if (node.init) {
+                checkSemicolonSpacing(context.getTokenAfter(node.init), node);
+            }
+
+            if (node.test) {
+                checkSemicolonSpacing(context.getTokenAfter(node.test), node);
+            }
+        }
+    };
+};
+
+module.exports.schema = [
+    {
+        "type": "object",
+        "properties": {
+            "before": {
+                "type": "boolean"
+            },
+            "after": {
+                "type": "boolean"
+            }
+        },
+        "additionalProperties": false
+    }
+];

package/lib/rules/semi.js

@@ -1,136 +1,136 @@
-/**
- * @fileoverview Rule to flag missing semicolons.
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-module.exports = function(context) {
-
-    var OPT_OUT_PATTERN = /[\[\(\/\+\-]/; // One of [(/+-
-
-    var always = context.options[0] !== "never";
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /**
-     * Reports a semicolon error with appropriate location and message.
-     * @param {ASTNode} node The node with an extra or missing semicolon.
-     * @returns {void}
-     */
-    function report(node) {
-        var message = always ? "Missing semicolon." : "Extra semicolon.";
-        context.report(node, context.getLastToken(node).loc.end, message);
-    }
-
-    /**
-     * Checks whether a token is a semicolon punctuator.
-     * @param {Token} token The token.
-     * @returns {boolean} True if token is a semicolon punctuator.
-     */
-    function isSemicolon(token) {
-        return (token.type === "Punctuator" && token.value === ";");
-    }
-
-    /**
-     * Check if a semicolon is unnecessary, only true if:
-     *   - next token is on a new line and is not one of the opt-out tokens
-     *   - next token is a valid statement divider
-     * @param {Token} lastToken last token of current node.
-     * @returns {boolean} whether the semicolon is unnecessary.
-     */
-    function isUnnecessarySemicolon(lastToken) {
-        var isDivider, isOptOutToken, lastTokenLine, nextToken, nextTokenLine;
-
-        if (!isSemicolon(lastToken)) {
-            return false;
-        }
-
-        nextToken = context.getTokenAfter(lastToken);
-
-        if (!nextToken) {
-            return true;
-        }
-
-        lastTokenLine = lastToken.loc.end.line;
-        nextTokenLine = nextToken.loc.start.line;
-        isOptOutToken = OPT_OUT_PATTERN.test(nextToken.value);
-        isDivider = (nextToken.value === "}" || nextToken.value === ";");
-
-        return (lastTokenLine !== nextTokenLine && !isOptOutToken) || isDivider;
-    }
-
-    /**
-     * Checks a node to see if it's followed by a semicolon.
-     * @param {ASTNode} node The node to check.
-     * @returns {void}
-     */
-    function checkForSemicolon(node) {
-        var lastToken = context.getLastToken(node);
-
-        if (always) {
-            if (!isSemicolon(lastToken)) {
-                report(node);
-            }
-        } else {
-            if (isUnnecessarySemicolon(lastToken)) {
-                report(node);
-            }
-        }
-    }
-
-    /**
-     * Checks to see if there's a semicolon after a variable declaration.
-     * @param {ASTNode} node The node to check.
-     * @returns {void}
-     */
-    function checkForSemicolonForVariableDeclaration(node) {
-        var ancestors = context.getAncestors(),
-            parentIndex = ancestors.length - 1,
-            parent = ancestors[parentIndex];
-
-        if ((parent.type !== "ForStatement" || parent.init !== node) &&
-            (!/^For(?:In|Of)Statement/.test(parent.type) || parent.left !== node)
-        ) {
-            checkForSemicolon(node);
-        }
-    }
-
-    //--------------------------------------------------------------------------
-    // Public API
-    //--------------------------------------------------------------------------
-
-    return {
-
-        "VariableDeclaration": checkForSemicolonForVariableDeclaration,
-        "ExpressionStatement": checkForSemicolon,
-        "ReturnStatement": checkForSemicolon,
-        "ThrowStatement": checkForSemicolon,
-        "DebuggerStatement": checkForSemicolon,
-        "BreakStatement": checkForSemicolon,
-        "ContinueStatement": checkForSemicolon,
-        "ImportDeclaration": checkForSemicolon,
-        "ExportAllDeclaration": checkForSemicolon,
-        "ExportNamedDeclaration": function (node) {
-            if (!node.declaration) {
-                checkForSemicolon(node);
-            }
-        },
-        "ExportDefaultDeclaration": function (node) {
-            if (!/(?:Class|Function)Declaration/.test(node.declaration.type)) {
-                checkForSemicolon(node);
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["always", "never"]
-    }
-];
+/**
+ * @fileoverview Rule to flag missing semicolons.
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+module.exports = function(context) {
+
+    var OPT_OUT_PATTERN = /[\[\(\/\+\-]/; // One of [(/+-
+
+    var always = context.options[0] !== "never";
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Reports a semicolon error with appropriate location and message.
+     * @param {ASTNode} node The node with an extra or missing semicolon.
+     * @returns {void}
+     */
+    function report(node) {
+        var message = always ? "Missing semicolon." : "Extra semicolon.";
+        context.report(node, context.getLastToken(node).loc.end, message);
+    }
+
+    /**
+     * Checks whether a token is a semicolon punctuator.
+     * @param {Token} token The token.
+     * @returns {boolean} True if token is a semicolon punctuator.
+     */
+    function isSemicolon(token) {
+        return (token.type === "Punctuator" && token.value === ";");
+    }
+
+    /**
+     * Check if a semicolon is unnecessary, only true if:
+     *   - next token is on a new line and is not one of the opt-out tokens
+     *   - next token is a valid statement divider
+     * @param {Token} lastToken last token of current node.
+     * @returns {boolean} whether the semicolon is unnecessary.
+     */
+    function isUnnecessarySemicolon(lastToken) {
+        var isDivider, isOptOutToken, lastTokenLine, nextToken, nextTokenLine;
+
+        if (!isSemicolon(lastToken)) {
+            return false;
+        }
+
+        nextToken = context.getTokenAfter(lastToken);
+
+        if (!nextToken) {
+            return true;
+        }
+
+        lastTokenLine = lastToken.loc.end.line;
+        nextTokenLine = nextToken.loc.start.line;
+        isOptOutToken = OPT_OUT_PATTERN.test(nextToken.value);
+        isDivider = (nextToken.value === "}" || nextToken.value === ";");
+
+        return (lastTokenLine !== nextTokenLine && !isOptOutToken) || isDivider;
+    }
+
+    /**
+     * Checks a node to see if it's followed by a semicolon.
+     * @param {ASTNode} node The node to check.
+     * @returns {void}
+     */
+    function checkForSemicolon(node) {
+        var lastToken = context.getLastToken(node);
+
+        if (always) {
+            if (!isSemicolon(lastToken)) {
+                report(node);
+            }
+        } else {
+            if (isUnnecessarySemicolon(lastToken)) {
+                report(node);
+            }
+        }
+    }
+
+    /**
+     * Checks to see if there's a semicolon after a variable declaration.
+     * @param {ASTNode} node The node to check.
+     * @returns {void}
+     */
+    function checkForSemicolonForVariableDeclaration(node) {
+        var ancestors = context.getAncestors(),
+            parentIndex = ancestors.length - 1,
+            parent = ancestors[parentIndex];
+
+        if ((parent.type !== "ForStatement" || parent.init !== node) &&
+            (!/^For(?:In|Of)Statement/.test(parent.type) || parent.left !== node)
+        ) {
+            checkForSemicolon(node);
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Public API
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "VariableDeclaration": checkForSemicolonForVariableDeclaration,
+        "ExpressionStatement": checkForSemicolon,
+        "ReturnStatement": checkForSemicolon,
+        "ThrowStatement": checkForSemicolon,
+        "DebuggerStatement": checkForSemicolon,
+        "BreakStatement": checkForSemicolon,
+        "ContinueStatement": checkForSemicolon,
+        "ImportDeclaration": checkForSemicolon,
+        "ExportAllDeclaration": checkForSemicolon,
+        "ExportNamedDeclaration": function (node) {
+            if (!node.declaration) {
+                checkForSemicolon(node);
+            }
+        },
+        "ExportDefaultDeclaration": function (node) {
+            if (!/(?:Class|Function)Declaration/.test(node.declaration.type)) {
+                checkForSemicolon(node);
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["always", "never"]
+    }
+];