eslint 0.22.0 → 0.24.1

package/lib/rules/sort-vars.js

@@ -1,49 +1,49 @@
-/**
- * @fileoverview Rule to require sorting of variables within a single Variable Declaration block
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var configuration = context.options[0] || {},
-        ignoreCase = configuration.ignoreCase || false;
-
-    return {
-        "VariableDeclaration": function(node) {
-            node.declarations.reduce(function(memo, decl) {
-                var lastVariableName = memo.id.name,
-                    currenVariableName = decl.id.name;
-
-                if (ignoreCase) {
-                    lastVariableName = lastVariableName.toLowerCase();
-                    currenVariableName = currenVariableName.toLowerCase();
-                }
-
-                if (currenVariableName < lastVariableName) {
-                    context.report(decl, "Variables within the same declaration block should be sorted alphabetically");
-                    return memo;
-                } else {
-                    return decl;
-                }
-            }, node.declarations[0]);
-        }
-    };
-};
-
-module.exports.schema = [
-    {
-        "type": "object",
-        "properties": {
-            "ignoreCase": {
-                "type": "boolean"
-            }
-        },
-        "additionalProperties": false
-    }
-];
+/**
+ * @fileoverview Rule to require sorting of variables within a single Variable Declaration block
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var configuration = context.options[0] || {},
+        ignoreCase = configuration.ignoreCase || false;
+
+    return {
+        "VariableDeclaration": function(node) {
+            node.declarations.reduce(function(memo, decl) {
+                var lastVariableName = memo.id.name,
+                    currenVariableName = decl.id.name;
+
+                if (ignoreCase) {
+                    lastVariableName = lastVariableName.toLowerCase();
+                    currenVariableName = currenVariableName.toLowerCase();
+                }
+
+                if (currenVariableName < lastVariableName) {
+                    context.report(decl, "Variables within the same declaration block should be sorted alphabetically");
+                    return memo;
+                } else {
+                    return decl;
+                }
+            }, node.declarations[0]);
+        }
+    };
+};
+
+module.exports.schema = [
+    {
+        "type": "object",
+        "properties": {
+            "ignoreCase": {
+                "type": "boolean"
+            }
+        },
+        "additionalProperties": false
+    }
+];

package/lib/rules/space-after-function-name.js

@@ -1,49 +1,49 @@
-/**
- * @fileoverview Rule to enforce consistent spacing after function names
- * @author Roberto Vidal
- * @copyright 2014 Roberto Vidal. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var requiresSpace = context.options[0] === "always";
-
-    /**
-     * Reports if the give named function node has the correct spacing after its name
-     *
-     * @param {ASTNode} node  The node to which the potential problem belongs.
-     * @returns {void}
-     */
-    function check(node) {
-        var tokens = context.getFirstTokens(node, 3),
-            hasSpace = tokens[1].range[1] < tokens[2].range[0];
-
-        if (hasSpace !== requiresSpace) {
-            context.report(node, "Function name \"{{name}}\" must {{not}}be followed by whitespace.", {
-                name: node.id.name,
-                not: requiresSpace ? "" : "not "
-            });
-        }
-    }
-
-    return {
-        "FunctionDeclaration": check,
-        "FunctionExpression": function (node) {
-            if (node.id) {
-                check(node);
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["always", "never"]
-    }
-];
+/**
+ * @fileoverview Rule to enforce consistent spacing after function names
+ * @author Roberto Vidal
+ * @copyright 2014 Roberto Vidal. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var requiresSpace = context.options[0] === "always";
+
+    /**
+     * Reports if the give named function node has the correct spacing after its name
+     *
+     * @param {ASTNode} node  The node to which the potential problem belongs.
+     * @returns {void}
+     */
+    function check(node) {
+        var tokens = context.getFirstTokens(node, 3),
+            hasSpace = tokens[1].range[1] < tokens[2].range[0];
+
+        if (hasSpace !== requiresSpace) {
+            context.report(node, "Function name \"{{name}}\" must {{not}}be followed by whitespace.", {
+                name: node.id.name,
+                not: requiresSpace ? "" : "not "
+            });
+        }
+    }
+
+    return {
+        "FunctionDeclaration": check,
+        "FunctionExpression": function (node) {
+            if (node.id) {
+                check(node);
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["always", "never"]
+    }
+];

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

@@ -1,82 +1,82 @@
-/**
- * @fileoverview Rule to enforce the number of spaces after certain keywords
- * @author Nick Fisher
- * @copyright 2014 Nick Fisher. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    // unless the first option is `"never"`, then a space is required
-    var requiresSpace = context.options[0] !== "never";
-
-    /**
-     * Check if the separation of two adjacent tokens meets the spacing rules, and report a problem if not.
-     *
-     * @param {ASTNode} node  The node to which the potential problem belongs.
-     * @param {Token} left    The first token.
-     * @param {Token} right   The second token
-     * @returns {void}
-     */
-    function checkTokens(node, left, right) {
-        var hasSpace = left.range[1] < right.range[0],
-            value = left.value;
-
-        if (hasSpace !== requiresSpace) {
-            context.report(node, "Keyword \"{{value}}\" must {{not}}be followed by whitespace.", {
-                value: value,
-                not: requiresSpace ? "" : "not "
-            });
-        }
-    }
-
-    /**
-     * Check if the given node (`if`, `for`, `while`, etc), has the correct spacing after it.
-     * @param {ASTNode} node The node to check.
-     * @returns {void}
-     */
-    function check(node) {
-        var tokens = context.getFirstTokens(node, 2);
-        checkTokens(node, tokens[0], tokens[1]);
-    }
-
-    return {
-        "IfStatement": function (node) {
-            check(node);
-            // check the `else`
-            if (node.alternate && node.alternate.type !== "IfStatement") {
-                checkTokens(node.alternate, context.getTokenBefore(node.alternate), context.getFirstToken(node.alternate));
-            }
-        },
-        "ForStatement": check,
-        "ForOfStatement": check,
-        "ForInStatement": check,
-        "WhileStatement": check,
-        "DoWhileStatement": function (node) {
-            check(node);
-            // check the `while`
-            var whileTokens = context.getTokensBefore(node.test, 2);
-            checkTokens(node, whileTokens[0], whileTokens[1]);
-        },
-        "SwitchStatement": check,
-        "TryStatement": function (node) {
-            check(node);
-            // check the `finally`
-            if (node.finalizer) {
-                checkTokens(node.finalizer, context.getTokenBefore(node.finalizer), context.getFirstToken(node.finalizer));
-            }
-        },
-        "CatchStatement": check,
-        "WithStatement": check
-    };
-};
-
-module.exports.schema = [
-    {
-        "enum": ["always", "never"]
-    }
-];
+/**
+ * @fileoverview Rule to enforce the number of spaces after certain keywords
+ * @author Nick Fisher
+ * @copyright 2014 Nick Fisher. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    // unless the first option is `"never"`, then a space is required
+    var requiresSpace = context.options[0] !== "never";
+
+    /**
+     * Check if the separation of two adjacent tokens meets the spacing rules, and report a problem if not.
+     *
+     * @param {ASTNode} node  The node to which the potential problem belongs.
+     * @param {Token} left    The first token.
+     * @param {Token} right   The second token
+     * @returns {void}
+     */
+    function checkTokens(node, left, right) {
+        var hasSpace = left.range[1] < right.range[0],
+            value = left.value;
+
+        if (hasSpace !== requiresSpace) {
+            context.report(node, "Keyword \"{{value}}\" must {{not}}be followed by whitespace.", {
+                value: value,
+                not: requiresSpace ? "" : "not "
+            });
+        }
+    }
+
+    /**
+     * Check if the given node (`if`, `for`, `while`, etc), has the correct spacing after it.
+     * @param {ASTNode} node The node to check.
+     * @returns {void}
+     */
+    function check(node) {
+        var tokens = context.getFirstTokens(node, 2);
+        checkTokens(node, tokens[0], tokens[1]);
+    }
+
+    return {
+        "IfStatement": function (node) {
+            check(node);
+            // check the `else`
+            if (node.alternate && node.alternate.type !== "IfStatement") {
+                checkTokens(node.alternate, context.getTokenBefore(node.alternate), context.getFirstToken(node.alternate));
+            }
+        },
+        "ForStatement": check,
+        "ForOfStatement": check,
+        "ForInStatement": check,
+        "WhileStatement": check,
+        "DoWhileStatement": function (node) {
+            check(node);
+            // check the `while`
+            var whileTokens = context.getTokensAfter(node.body, 2);
+            checkTokens(node, whileTokens[0], whileTokens[1]);
+        },
+        "SwitchStatement": check,
+        "TryStatement": function (node) {
+            check(node);
+            // check the `finally`
+            if (node.finalizer) {
+                checkTokens(node.finalizer, context.getTokenBefore(node.finalizer), context.getFirstToken(node.finalizer));
+            }
+        },
+        "CatchStatement": check,
+        "WithStatement": check
+    };
+};
+
+module.exports.schema = [
+    {
+        "enum": ["always", "never"]
+    }
+];

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

@@ -1,91 +1,91 @@
-/**
- * @fileoverview A rule to ensure whitespace before blocks.
- * @author Mathias Schreck <https://github.com/lo1tuma>
- * @copyright 2014 Mathias Schreck. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function (context) {
-    var requireSpace = context.options[0] !== "never";
-
-    /**
-     * 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 two adjacent tokens are on the same line.
-     * @param {Object} left - The left token object.
-     * @param {Object} right - The right token object.
-     * @returns {boolean} Whether or not the tokens are on the same line.
-     */
-    function isSameLine(left, right) {
-        return left.loc.start.line === right.loc.start.line;
-    }
-
-    /**
-     * Checks the given BlockStatement node has a preceding space if it doesn’t start on a new line.
-     * @param {ASTNode|Token} node The AST node of a BlockStatement.
-     * @returns {void} undefined.
-     */
-    function checkPrecedingSpace(node) {
-        var precedingToken = context.getTokenBefore(node),
-            hasSpace;
-
-        if (precedingToken && isSameLine(precedingToken, node)) {
-            hasSpace = isSpaced(precedingToken, node);
-
-            if (requireSpace) {
-                if (!hasSpace) {
-                    context.report(node, "Missing space before opening brace.");
-                }
-            } else {
-                if (hasSpace) {
-                    context.report(node, "Unexpected space before opening brace.");
-                }
-            }
-        }
-    }
-
-    /**
-     * Checks if the CaseBlock of an given SwitchStatement node has a preceding space.
-     * @param {ASTNode} node The node of a SwitchStatement.
-     * @returns {void} undefined.
-     */
-    function checkSpaceBeforeCaseBlock(node) {
-        var cases = node.cases,
-            firstCase,
-            openingBrace;
-
-        if (cases.length > 0) {
-            firstCase = cases[0];
-            openingBrace = context.getTokenBefore(firstCase);
-        } else {
-            openingBrace = context.getLastToken(node, 1);
-        }
-
-        checkPrecedingSpace(openingBrace);
-    }
-
-    return {
-        "BlockStatement": checkPrecedingSpace,
-        "SwitchStatement": checkSpaceBeforeCaseBlock
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["always", "never"]
-    }
-];
+/**
+ * @fileoverview A rule to ensure whitespace before blocks.
+ * @author Mathias Schreck <https://github.com/lo1tuma>
+ * @copyright 2014 Mathias Schreck. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function (context) {
+    var requireSpace = context.options[0] !== "never";
+
+    /**
+     * 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 two adjacent tokens are on the same line.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not the tokens are on the same line.
+     */
+    function isSameLine(left, right) {
+        return left.loc.start.line === right.loc.start.line;
+    }
+
+    /**
+     * Checks the given BlockStatement node has a preceding space if it doesn’t start on a new line.
+     * @param {ASTNode|Token} node The AST node of a BlockStatement.
+     * @returns {void} undefined.
+     */
+    function checkPrecedingSpace(node) {
+        var precedingToken = context.getTokenBefore(node),
+            hasSpace;
+
+        if (precedingToken && isSameLine(precedingToken, node)) {
+            hasSpace = isSpaced(precedingToken, node);
+
+            if (requireSpace) {
+                if (!hasSpace) {
+                    context.report(node, "Missing space before opening brace.");
+                }
+            } else {
+                if (hasSpace) {
+                    context.report(node, "Unexpected space before opening brace.");
+                }
+            }
+        }
+    }
+
+    /**
+     * Checks if the CaseBlock of an given SwitchStatement node has a preceding space.
+     * @param {ASTNode} node The node of a SwitchStatement.
+     * @returns {void} undefined.
+     */
+    function checkSpaceBeforeCaseBlock(node) {
+        var cases = node.cases,
+            firstCase,
+            openingBrace;
+
+        if (cases.length > 0) {
+            firstCase = cases[0];
+            openingBrace = context.getTokenBefore(firstCase);
+        } else {
+            openingBrace = context.getLastToken(node, 1);
+        }
+
+        checkPrecedingSpace(openingBrace);
+    }
+
+    return {
+        "BlockStatement": checkPrecedingSpace,
+        "SwitchStatement": checkSpaceBeforeCaseBlock
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["always", "never"]
+    }
+];