eslint 0.22.0 → 0.24.1

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

@@ -1,83 +1,83 @@
-/**
- * @fileoverview Rule to flag use of function declaration identifiers as variables.
- * @author Ian Christian Myers
- * @copyright 2013 Ian Christian Myers. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /*
-     * Walk the scope chain looking for either a FunctionDeclaration or a
-     * VariableDeclaration with the same name as left-hand side of the
-     * AssignmentExpression. If we find the FunctionDeclaration first, then we
-     * warn, because a FunctionDeclaration is trying to become a Variable or a
-     * FunctionExpression. If we find a VariableDeclaration first, then we have
-     * a legitimate shadow variable.
-     */
-    function checkIfIdentifierIsFunction(scope, name) {
-        var variable,
-            def,
-            i,
-            j;
-
-        // Loop over all of the identifiers available in scope.
-        for (i = 0; i < scope.variables.length; i++) {
-            variable = scope.variables[i];
-
-            // For each identifier, see if it was defined in _this_ scope.
-            for (j = 0; j < variable.defs.length; j++) {
-                def = variable.defs[j];
-
-                // Identifier is a function and was declared in this scope
-                if (def.type === "FunctionName" && def.name.name === name) {
-                    return true;
-                }
-
-                // Identifier is a variable and was declared in this scope. This
-                // is a legitimate shadow variable.
-                if (def.name && def.name.name === name) {
-                    return false;
-                }
-            }
-        }
-
-        // Check the upper scope.
-        if (scope.upper) {
-            return checkIfIdentifierIsFunction(scope.upper, name);
-        }
-
-        // We've reached the global scope and haven't found anything.
-        return false;
-    }
-
-    //--------------------------------------------------------------------------
-    // Public API
-    //--------------------------------------------------------------------------
-
-    return {
-
-        "AssignmentExpression": function(node) {
-            var scope = context.getScope(),
-                name = node.left.name;
-
-            if (checkIfIdentifierIsFunction(scope, name)) {
-                context.report(node, "'{{name}}' is a function.", { name: name });
-            }
-
-        }
-
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of function declaration identifiers as variables.
+ * @author Ian Christian Myers
+ * @copyright 2013 Ian Christian Myers. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /*
+     * Walk the scope chain looking for either a FunctionDeclaration or a
+     * VariableDeclaration with the same name as left-hand side of the
+     * AssignmentExpression. If we find the FunctionDeclaration first, then we
+     * warn, because a FunctionDeclaration is trying to become a Variable or a
+     * FunctionExpression. If we find a VariableDeclaration first, then we have
+     * a legitimate shadow variable.
+     */
+    function checkIfIdentifierIsFunction(scope, name) {
+        var variable,
+            def,
+            i,
+            j;
+
+        // Loop over all of the identifiers available in scope.
+        for (i = 0; i < scope.variables.length; i++) {
+            variable = scope.variables[i];
+
+            // For each identifier, see if it was defined in _this_ scope.
+            for (j = 0; j < variable.defs.length; j++) {
+                def = variable.defs[j];
+
+                // Identifier is a function and was declared in this scope
+                if (def.type === "FunctionName" && def.name.name === name) {
+                    return true;
+                }
+
+                // Identifier is a variable and was declared in this scope. This
+                // is a legitimate shadow variable.
+                if (def.name && def.name.name === name) {
+                    return false;
+                }
+            }
+        }
+
+        // Check the upper scope.
+        if (scope.upper) {
+            return checkIfIdentifierIsFunction(scope.upper, name);
+        }
+
+        // We've reached the global scope and haven't found anything.
+        return false;
+    }
+
+    //--------------------------------------------------------------------------
+    // Public API
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "AssignmentExpression": function(node) {
+            var scope = context.getScope(),
+                name = node.left.name;
+
+            if (checkIfIdentifierIsFunction(scope, name)) {
+                context.report(node, "'{{name}}' is a function.", { name: name });
+            }
+
+        }
+
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-implied-eval.js

@@ -1,76 +1,76 @@
-/**
- * @fileoverview Rule to flag use of implied eval via setTimeout and setInterval
- * @author James Allardice
- * @copyright 2015 Mathias Schreck. All rights reserved.
- * @copyright 2013 James Allardice. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-    var IMPLIED_EVAL = /set(?:Timeout|Interval)/;
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /**
-     * Checks if the first argument of a given CallExpression node is a string literal.
-     * @param {ASTNode} node The CallExpression node the check.
-     * @returns {boolean} True if the first argument is a string literal, false if not.
-     */
-    function hasStringLiteralArgument(node) {
-        var firstArgument = node.arguments[0];
-
-        return firstArgument && firstArgument.type === "Literal" && typeof firstArgument.value === "string";
-    }
-
-    /**
-     * Checks if the given MemberExpression node is window.setTimeout or window.setInterval.
-     * @param {ASTNode} node The MemberExpression node to check.
-     * @returns {boolean} Whether or not the given node is window.set*.
-     */
-    function isSetMemberExpression(node) {
-        var object = node.object,
-            property = node.property,
-            hasSetPropertyName = IMPLIED_EVAL.test(property.name) || IMPLIED_EVAL.test(property.value);
-
-        return object.name === "window" && hasSetPropertyName;
-
-    }
-
-    /**
-     * Determines if a node represents a call to setTimeout/setInterval with
-     * a string argument.
-     * @param {ASTNode} node The node to check.
-     * @returns {boolean} True if the node matches, false if not.
-     * @private
-     */
-    function isImpliedEval(node) {
-        var isMemberExpression = (node.callee.type === "MemberExpression"),
-            isIdentifier = (node.callee.type === "Identifier"),
-            isSetMethod = (isIdentifier && IMPLIED_EVAL.test(node.callee.name)) ||
-                (isMemberExpression && isSetMemberExpression(node.callee));
-
-        return isSetMethod && hasStringLiteralArgument(node);
-    }
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    return {
-        "CallExpression": function(node) {
-            if (isImpliedEval(node)) {
-                context.report(node, "Implied eval. Consider passing a function instead of a string.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of implied eval via setTimeout and setInterval
+ * @author James Allardice
+ * @copyright 2015 Mathias Schreck. All rights reserved.
+ * @copyright 2013 James Allardice. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+    var IMPLIED_EVAL = /set(?:Timeout|Interval)|execScript/;
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Checks if the first argument of a given CallExpression node is a string literal.
+     * @param {ASTNode} node The CallExpression node the check.
+     * @returns {boolean} True if the first argument is a string literal, false if not.
+     */
+    function hasStringLiteralArgument(node) {
+        var firstArgument = node.arguments[0];
+
+        return firstArgument && firstArgument.type === "Literal" && typeof firstArgument.value === "string";
+    }
+
+    /**
+     * Checks if the given MemberExpression node is window.setTimeout or window.setInterval.
+     * @param {ASTNode} node The MemberExpression node to check.
+     * @returns {boolean} Whether or not the given node is window.set*.
+     */
+    function isSetMemberExpression(node) {
+        var object = node.object,
+            property = node.property,
+            hasSetPropertyName = IMPLIED_EVAL.test(property.name) || IMPLIED_EVAL.test(property.value);
+
+        return object.name === "window" && hasSetPropertyName;
+
+    }
+
+    /**
+     * Determines if a node represents a call to setTimeout/setInterval with
+     * a string argument.
+     * @param {ASTNode} node The node to check.
+     * @returns {boolean} True if the node matches, false if not.
+     * @private
+     */
+    function isImpliedEval(node) {
+        var isMemberExpression = (node.callee.type === "MemberExpression"),
+            isIdentifier = (node.callee.type === "Identifier"),
+            isSetMethod = (isIdentifier && IMPLIED_EVAL.test(node.callee.name)) ||
+                (isMemberExpression && isSetMemberExpression(node.callee));
+
+        return isSetMethod && hasStringLiteralArgument(node);
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+        "CallExpression": function(node) {
+            if (isImpliedEval(node)) {
+                context.report(node, "Implied eval. Consider passing a function instead of a string.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

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

@@ -1,49 +1,49 @@
-/**
- * @fileoverview Enforces or disallows inline comments.
- * @author Greg Cochard
- * @copyright 2014 Greg Cochard. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * Will check that comments are not on lines starting with or ending with code
-     * @param {ASTNode} node The comment node to check
-     * @private
-     * @returns {void}
-     */
-    function testCodeAroundComment(node) {
-
-        // Get the whole line and cut it off at the start of the comment
-        var startLine = String(context.getSourceLines()[node.loc.start.line - 1]);
-        var endLine = String(context.getSourceLines()[node.loc.end.line - 1]);
-
-        var preamble = startLine.slice(0, node.loc.start.column).trim();
-
-        // Also check after the comment
-        var postamble = endLine.slice(node.loc.end.column).trim();
-
-        // Should be empty if there was only whitespace around the comment
-        if (preamble || postamble) {
-            context.report(node, "Unexpected comment inline with code.");
-        }
-    }
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    return {
-
-        "LineComment": testCodeAroundComment,
-        "BlockComment": testCodeAroundComment
-
-    };
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Enforces or disallows inline comments.
+ * @author Greg Cochard
+ * @copyright 2014 Greg Cochard. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Will check that comments are not on lines starting with or ending with code
+     * @param {ASTNode} node The comment node to check
+     * @private
+     * @returns {void}
+     */
+    function testCodeAroundComment(node) {
+
+        // Get the whole line and cut it off at the start of the comment
+        var startLine = String(context.getSourceLines()[node.loc.start.line - 1]);
+        var endLine = String(context.getSourceLines()[node.loc.end.line - 1]);
+
+        var preamble = startLine.slice(0, node.loc.start.column).trim();
+
+        // Also check after the comment
+        var postamble = endLine.slice(node.loc.end.column).trim();
+
+        // Should be empty if there was only whitespace around the comment
+        if (preamble || postamble) {
+            context.report(node, "Unexpected comment inline with code.");
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "LineComment": testCodeAroundComment,
+        "BlockComment": testCodeAroundComment
+
+    };
+};
+
+module.exports.schema = [];

package/lib/rules/no-inner-declarations.js

@@ -1,78 +1,78 @@
-/**
- * @fileoverview Rule to enforce declarations in program or function body root.
- * @author Brandon Mills
- * @copyright 2014 Brandon Mills. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * Find the nearest Program or Function ancestor node.
-     * @returns {Object} Ancestor's type and distance from node.
-     */
-    function nearestBody() {
-        var ancestors = context.getAncestors(),
-            ancestor = ancestors.pop(),
-            generation = 1;
-
-        while (ancestor && ["Program", "FunctionDeclaration",
-                "FunctionExpression", "ArrowFunctionExpression"
-                ].indexOf(ancestor.type) < 0) {
-            generation += 1;
-            ancestor = ancestors.pop();
-        }
-
-        return {
-            // Type of containing ancestor
-            type: ancestor.type,
-            // Separation between ancestor and node
-            distance: generation
-        };
-    }
-
-    /**
-     * Ensure that a given node is at a program or function body's root.
-     * @param {ASTNode} node Declaration node to check.
-     * @returns {void}
-     */
-    function check(node) {
-        var body = nearestBody(node),
-            valid = ((body.type === "Program" && body.distance === 1) ||
-                body.distance === 2);
-
-        if (!valid) {
-            context.report(node, "Move {{type}} declaration to {{body}} root.",
-                {
-                    type: (node.type === "FunctionDeclaration" ?
-                        "function" : "variable"),
-                    body: (body.type === "Program" ?
-                        "program" : "function body")
-                }
-            );
-        }
-    }
-
-    return {
-
-        "FunctionDeclaration": check,
-        "VariableDeclaration": function(node) {
-            if (context.options[0] === "both" && node.kind === "var") {
-                check(node);
-            }
-        }
-
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["functions", "both"]
-    }
-];
+/**
+ * @fileoverview Rule to enforce declarations in program or function body root.
+ * @author Brandon Mills
+ * @copyright 2014 Brandon Mills. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Find the nearest Program or Function ancestor node.
+     * @returns {Object} Ancestor's type and distance from node.
+     */
+    function nearestBody() {
+        var ancestors = context.getAncestors(),
+            ancestor = ancestors.pop(),
+            generation = 1;
+
+        while (ancestor && ["Program", "FunctionDeclaration",
+                "FunctionExpression", "ArrowFunctionExpression"
+                ].indexOf(ancestor.type) < 0) {
+            generation += 1;
+            ancestor = ancestors.pop();
+        }
+
+        return {
+            // Type of containing ancestor
+            type: ancestor.type,
+            // Separation between ancestor and node
+            distance: generation
+        };
+    }
+
+    /**
+     * Ensure that a given node is at a program or function body's root.
+     * @param {ASTNode} node Declaration node to check.
+     * @returns {void}
+     */
+    function check(node) {
+        var body = nearestBody(node),
+            valid = ((body.type === "Program" && body.distance === 1) ||
+                body.distance === 2);
+
+        if (!valid) {
+            context.report(node, "Move {{type}} declaration to {{body}} root.",
+                {
+                    type: (node.type === "FunctionDeclaration" ?
+                        "function" : "variable"),
+                    body: (body.type === "Program" ?
+                        "program" : "function body")
+                }
+            );
+        }
+    }
+
+    return {
+
+        "FunctionDeclaration": check,
+        "VariableDeclaration": function(node) {
+            if (context.options[0] === "both" && node.kind === "var") {
+                check(node);
+            }
+        }
+
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["functions", "both"]
+    }
+];