eslint 0.22.0 → 0.24.1

package/lib/rules/no-lone-blocks.js

@@ -1,27 +1,106 @@
-/**
- * @fileoverview Rule to flag blocks with no reason to exist
- * @author Brandon Mills
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-        "BlockStatement": function (node) {
-            // Check for any occurrence of BlockStatement > BlockStatement or
-            // Program > BlockStatement
-            var parent = context.getAncestors().pop();
-            if (parent.type === "BlockStatement" || parent.type === "Program") {
-                context.report(node, "Block is nested inside another block.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag blocks with no reason to exist
+ * @author Brandon Mills
+ * @copyright 2015 Roberto Vidal. All rights reserved.
+ * @copyright 2014 Brandon Mills. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    // A stack of lone blocks to be checked for block-level bindings
+    var loneBlocks = [],
+        ruleDef;
+
+    /**
+     * Reports a node as invalid.
+     * @param {ASTNode} node - The node to be reported.
+     * @returns {void}
+    */
+    function report(node) {
+        var parent = context.getAncestors().pop();
+        context.report(node, parent.type === "Program" ?
+            "Block is redundant." :
+            "Nested block is redundant."
+        );
+    }
+
+    /**
+     * Checks for any ocurrence of BlockStatement > BlockStatement or Program > BlockStatement
+     * @returns {boolean} True if the current node is a lone block.
+    */
+    function isLoneBlock() {
+        var parent = context.getAncestors().pop();
+        return parent.type === "BlockStatement" || parent.type === "Program";
+    }
+
+    /**
+     * Checks the enclosing block of the current node for block-level bindings,
+     * and "marks it" as valid if any.
+     * @returns {void}
+    */
+    function markLoneBlock() {
+        if (loneBlocks.length === 0) {
+            return;
+        }
+
+        var block = context.getAncestors().pop();
+
+        if (loneBlocks[loneBlocks.length - 1] === block) {
+            loneBlocks.pop();
+        }
+    }
+
+    // Default rule definition: report all lone blocks
+    ruleDef = {
+        BlockStatement: function(node) {
+            if (isLoneBlock(node)) {
+                report(node);
+            }
+        }
+    };
+
+    // ES6: report blocks without block-level bindings
+    if (context.ecmaFeatures.blockBindings || context.ecmaFeatures.classes) {
+        ruleDef = {
+            "BlockStatement": function(node) {
+                if (isLoneBlock(node)) {
+                    loneBlocks.push(node);
+                }
+            },
+            "BlockStatement:exit": function(node) {
+                if (loneBlocks.length > 0 && loneBlocks[loneBlocks.length - 1] === node) {
+                    loneBlocks.pop();
+                    report(node);
+                }
+            }
+        };
+    }
+
+    if (context.ecmaFeatures.blockBindings) {
+        ruleDef.VariableDeclaration = function(node) {
+            if (node.kind === "let" || node.kind === "const") {
+                markLoneBlock(node);
+            }
+        };
+
+        ruleDef.FunctionDeclaration = function(node) {
+            if (context.getScope().isStrict) {
+                markLoneBlock(node);
+            }
+        };
+    }
+
+    if (context.ecmaFeatures.classes) {
+        ruleDef.ClassDeclaration = markLoneBlock;
+    }
+
+    return ruleDef;
+};
+
+module.exports.schema = [];

package/lib/rules/no-lonely-if.js

@@ -1,30 +1,30 @@
-/**
- * @fileoverview Rule to disallow if as the only statmenet in an else block
- * @author Brandon Mills
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-        "IfStatement": function(node) {
-            var ancestors = context.getAncestors(),
-                parent = ancestors.pop(),
-                grandparent = ancestors.pop();
-
-            if (parent && parent.type === "BlockStatement" &&
-                    parent.body.length === 1 && grandparent &&
-                    grandparent.type === "IfStatement" &&
-                    parent === grandparent.alternate) {
-                context.report(node, "Unexpected if as the only statement in an else block.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to disallow if as the only statmenet in an else block
+ * @author Brandon Mills
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+        "IfStatement": function(node) {
+            var ancestors = context.getAncestors(),
+                parent = ancestors.pop(),
+                grandparent = ancestors.pop();
+
+            if (parent && parent.type === "BlockStatement" &&
+                    parent.body.length === 1 && grandparent &&
+                    grandparent.type === "IfStatement" &&
+                    parent === grandparent.alternate) {
+                context.report(node, "Unexpected if as the only statement in an else block.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-loop-func.js

@@ -1,58 +1,58 @@
-/**
- * @fileoverview Rule to flag creation of function inside a loop
- * @author Ilya Volodin
- * @copyright 2013 Ilya Volodin. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-    /**
-     * Reports if the given node has an ancestor node which is a loop.
-     * @param {ASTNode} node The AST node to check.
-     * @returns {boolean} Whether or not the node is within a loop.
-     */
-    function checkForLoops(node) {
-        var ancestors = context.getAncestors();
-
-        /**
-         * Checks if the given node is a loop and current context is in the loop.
-         * @param {ASTNode} ancestor The AST node to check.
-         * @param {number} index The index of ancestor in ancestors.
-         * @returns {boolean} Whether or not the node is a loop and current context is in the loop.
-         */
-        function isInLoop(ancestor, index) {
-            switch (ancestor.type) {
-                case "ForStatement":
-                    return ancestor.init !== ancestors[index + 1];
-
-                case "ForInStatement":
-                case "ForOfStatement":
-                    return ancestor.right !== ancestors[index + 1];
-
-                case "WhileStatement":
-                case "DoWhileStatement":
-                    return true;
-
-                default:
-                    return false;
-            }
-        }
-
-        if (ancestors.some(isInLoop)) {
-            context.report(node, "Don't make functions within a loop");
-        }
-    }
-
-    return {
-        "ArrowFunctionExpression": checkForLoops,
-        "FunctionExpression": checkForLoops,
-        "FunctionDeclaration": checkForLoops
-    };
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag creation of function inside a loop
+ * @author Ilya Volodin
+ * @copyright 2013 Ilya Volodin. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+    /**
+     * Reports if the given node has an ancestor node which is a loop.
+     * @param {ASTNode} node The AST node to check.
+     * @returns {boolean} Whether or not the node is within a loop.
+     */
+    function checkForLoops(node) {
+        var ancestors = context.getAncestors();
+
+        /**
+         * Checks if the given node is a loop and current context is in the loop.
+         * @param {ASTNode} ancestor The AST node to check.
+         * @param {number} index The index of ancestor in ancestors.
+         * @returns {boolean} Whether or not the node is a loop and current context is in the loop.
+         */
+        function isInLoop(ancestor, index) {
+            switch (ancestor.type) {
+                case "ForStatement":
+                    return ancestor.init !== ancestors[index + 1];
+
+                case "ForInStatement":
+                case "ForOfStatement":
+                    return ancestor.right !== ancestors[index + 1];
+
+                case "WhileStatement":
+                case "DoWhileStatement":
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        if (ancestors.some(isInLoop)) {
+            context.report(node, "Don't make functions within a loop");
+        }
+    }
+
+    return {
+        "ArrowFunctionExpression": checkForLoops,
+        "FunctionExpression": checkForLoops,
+        "FunctionDeclaration": checkForLoops
+    };
+};
+
+module.exports.schema = [];

package/lib/rules/no-mixed-requires.js

@@ -1,165 +1,165 @@
-/**
- * @fileoverview Rule to enforce grouped require statements for Node.JS
- * @author Raphael Pigulla
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * Returns the list of built-in modules.
-     *
-     * @returns {string[]} An array of built-in Node.js modules.
-     */
-    function getBuiltinModules() {
-        // This list is generated using `require("repl")._builtinLibs.concat('repl').sort()`
-        // This particular list is as per nodejs v0.12.2 and iojs v0.7.1
-        return [
-            "assert", "buffer", "child_process", "cluster", "crypto",
-            "dgram", "dns", "domain", "events", "fs", "http", "https",
-            "net", "os", "path", "punycode", "querystring", "readline",
-            "repl", "smalloc", "stream", "string_decoder", "tls", "tty",
-            "url", "util", "v8", "vm", "zlib"
-        ];
-    }
-
-    var BUILTIN_MODULES = getBuiltinModules();
-
-    var DECL_REQUIRE = "require",
-        DECL_UNINITIALIZED = "uninitialized",
-        DECL_OTHER = "other";
-
-    var REQ_CORE = "core",
-        REQ_FILE = "file",
-        REQ_MODULE = "module",
-        REQ_COMPUTED = "computed";
-
-    /**
-     * Determines the type of a declaration statement.
-     * @param {ASTNode} initExpression The init node of the VariableDeclarator.
-     * @returns {string} The type of declaration represented by the expression.
-     */
-    function getDeclarationType(initExpression) {
-        if (!initExpression) {
-            // "var x;"
-            return DECL_UNINITIALIZED;
-        }
-
-        if (initExpression.type === "CallExpression" &&
-            initExpression.callee.type === "Identifier" &&
-            initExpression.callee.name === "require"
-        ) {
-            // "var x = require('util');"
-            return DECL_REQUIRE;
-        } else if (initExpression.type === "MemberExpression") {
-            // "var x = require('glob').Glob;"
-            return getDeclarationType(initExpression.object);
-        }
-
-        // "var x = 42;"
-        return DECL_OTHER;
-    }
-
-    /**
-     * Determines the type of module that is loaded via require.
-     * @param {ASTNode} initExpression The init node of the VariableDeclarator.
-     * @returns {string} The module type.
-     */
-    function inferModuleType(initExpression) {
-        if (initExpression.type === "MemberExpression") {
-            // "var x = require('glob').Glob;"
-            return inferModuleType(initExpression.object);
-        } else if (initExpression.arguments.length === 0) {
-            // "var x = require();"
-            return REQ_COMPUTED;
-        }
-
-        var arg = initExpression.arguments[0];
-
-        if (arg.type !== "Literal" || typeof arg.value !== "string") {
-            // "var x = require(42);"
-            return REQ_COMPUTED;
-        }
-
-        if (BUILTIN_MODULES.indexOf(arg.value) !== -1) {
-            // "var fs = require('fs');"
-            return REQ_CORE;
-        } else if (/^\.{0,2}\//.test(arg.value)) {
-            // "var utils = require('./utils');"
-            return REQ_FILE;
-        } else {
-            // "var async = require('async');"
-            return REQ_MODULE;
-        }
-    }
-
-    /**
-     * Check if the list of variable declarations is mixed, i.e. whether it
-     * contains both require and other declarations.
-     * @param {ASTNode} declarations The list of VariableDeclarators.
-     * @returns {boolean} True if the declarations are mixed, false if not.
-     */
-    function isMixed(declarations) {
-        var contains = {};
-
-        declarations.forEach(function (declaration) {
-            var type = getDeclarationType(declaration.init);
-            contains[type] = true;
-        });
-
-        return !!(
-            contains[DECL_REQUIRE] &&
-            (contains[DECL_UNINITIALIZED] || contains[DECL_OTHER])
-        );
-    }
-
-    /**
-     * Check if all require declarations in the given list are of the same
-     * type.
-     * @param {ASTNode} declarations The list of VariableDeclarators.
-     * @returns {boolean} True if the declarations are grouped, false if not.
-     */
-    function isGrouped(declarations) {
-        var found = {};
-
-        declarations.forEach(function (declaration) {
-            if (getDeclarationType(declaration.init) === DECL_REQUIRE) {
-                found[inferModuleType(declaration.init)] = true;
-            }
-        });
-
-        return Object.keys(found).length <= 1;
-    }
-
-
-    return {
-
-        "VariableDeclaration": function(node) {
-            var grouping = !!context.options[0];
-
-            if (isMixed(node.declarations)) {
-                context.report(
-                    node,
-                    "Do not mix 'require' and other declarations."
-                );
-            } else if (grouping && !isGrouped(node.declarations)) {
-                context.report(
-                    node,
-                    "Do not mix core, module, file and computed requires."
-                );
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "type": "boolean"
-    }
-];
+/**
+ * @fileoverview Rule to enforce grouped require statements for Node.JS
+ * @author Raphael Pigulla
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Returns the list of built-in modules.
+     *
+     * @returns {string[]} An array of built-in Node.js modules.
+     */
+    function getBuiltinModules() {
+        // This list is generated using `require("repl")._builtinLibs.concat('repl').sort()`
+        // This particular list is as per nodejs v0.12.2 and iojs v0.7.1
+        return [
+            "assert", "buffer", "child_process", "cluster", "crypto",
+            "dgram", "dns", "domain", "events", "fs", "http", "https",
+            "net", "os", "path", "punycode", "querystring", "readline",
+            "repl", "smalloc", "stream", "string_decoder", "tls", "tty",
+            "url", "util", "v8", "vm", "zlib"
+        ];
+    }
+
+    var BUILTIN_MODULES = getBuiltinModules();
+
+    var DECL_REQUIRE = "require",
+        DECL_UNINITIALIZED = "uninitialized",
+        DECL_OTHER = "other";
+
+    var REQ_CORE = "core",
+        REQ_FILE = "file",
+        REQ_MODULE = "module",
+        REQ_COMPUTED = "computed";
+
+    /**
+     * Determines the type of a declaration statement.
+     * @param {ASTNode} initExpression The init node of the VariableDeclarator.
+     * @returns {string} The type of declaration represented by the expression.
+     */
+    function getDeclarationType(initExpression) {
+        if (!initExpression) {
+            // "var x;"
+            return DECL_UNINITIALIZED;
+        }
+
+        if (initExpression.type === "CallExpression" &&
+            initExpression.callee.type === "Identifier" &&
+            initExpression.callee.name === "require"
+        ) {
+            // "var x = require('util');"
+            return DECL_REQUIRE;
+        } else if (initExpression.type === "MemberExpression") {
+            // "var x = require('glob').Glob;"
+            return getDeclarationType(initExpression.object);
+        }
+
+        // "var x = 42;"
+        return DECL_OTHER;
+    }
+
+    /**
+     * Determines the type of module that is loaded via require.
+     * @param {ASTNode} initExpression The init node of the VariableDeclarator.
+     * @returns {string} The module type.
+     */
+    function inferModuleType(initExpression) {
+        if (initExpression.type === "MemberExpression") {
+            // "var x = require('glob').Glob;"
+            return inferModuleType(initExpression.object);
+        } else if (initExpression.arguments.length === 0) {
+            // "var x = require();"
+            return REQ_COMPUTED;
+        }
+
+        var arg = initExpression.arguments[0];
+
+        if (arg.type !== "Literal" || typeof arg.value !== "string") {
+            // "var x = require(42);"
+            return REQ_COMPUTED;
+        }
+
+        if (BUILTIN_MODULES.indexOf(arg.value) !== -1) {
+            // "var fs = require('fs');"
+            return REQ_CORE;
+        } else if (/^\.{0,2}\//.test(arg.value)) {
+            // "var utils = require('./utils');"
+            return REQ_FILE;
+        } else {
+            // "var async = require('async');"
+            return REQ_MODULE;
+        }
+    }
+
+    /**
+     * Check if the list of variable declarations is mixed, i.e. whether it
+     * contains both require and other declarations.
+     * @param {ASTNode} declarations The list of VariableDeclarators.
+     * @returns {boolean} True if the declarations are mixed, false if not.
+     */
+    function isMixed(declarations) {
+        var contains = {};
+
+        declarations.forEach(function (declaration) {
+            var type = getDeclarationType(declaration.init);
+            contains[type] = true;
+        });
+
+        return !!(
+            contains[DECL_REQUIRE] &&
+            (contains[DECL_UNINITIALIZED] || contains[DECL_OTHER])
+        );
+    }
+
+    /**
+     * Check if all require declarations in the given list are of the same
+     * type.
+     * @param {ASTNode} declarations The list of VariableDeclarators.
+     * @returns {boolean} True if the declarations are grouped, false if not.
+     */
+    function isGrouped(declarations) {
+        var found = {};
+
+        declarations.forEach(function (declaration) {
+            if (getDeclarationType(declaration.init) === DECL_REQUIRE) {
+                found[inferModuleType(declaration.init)] = true;
+            }
+        });
+
+        return Object.keys(found).length <= 1;
+    }
+
+
+    return {
+
+        "VariableDeclaration": function(node) {
+            var grouping = !!context.options[0];
+
+            if (isMixed(node.declarations)) {
+                context.report(
+                    node,
+                    "Do not mix 'require' and other declarations."
+                );
+            } else if (grouping && !isGrouped(node.declarations)) {
+                context.report(
+                    node,
+                    "Do not mix core, module, file and computed requires."
+                );
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "type": "boolean"
+    }
+];