eslint 0.22.0 → 0.24.1

package/lib/rules/vars-on-top.js

@@ -1,115 +1,115 @@
-/**
- * @fileoverview Rule to enforce var declarations are only at the top of a function.
- * @author Danny Fritz
- * @author Gyandeep Singh
- * @copyright 2014 Danny Fritz. All rights reserved.
- * @copyright 2014 Gyandeep Singh. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function (context) {
-    var errorMessage = "All \"var\" declarations must be at the top of the function scope.";
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /**
-     * @param {ASTNode} node - any node
-     * @returns {Boolean} whether the given node structurally represents a directive
-     */
-    function looksLikeDirective(node) {
-        return node.type === "ExpressionStatement" &&
-            node.expression.type === "Literal" && typeof node.expression.value === "string";
-    }
-
-    /**
-     * Check to see if its a ES6 import declaration
-     * @param {ASTNode} node - any node
-     * @returns {Boolean} whether the given node represents a import declaration
-     */
-    function looksLikeImport(node) {
-        return node.type === "ImportDeclaration" || node.type === "ImportSpecifier" ||
-            node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier";
-    }
-
-    /**
-     * Checks whether this variable is on top of the block body
-     * @param {ASTNode} node - The node to check
-     * @param {ASTNode[]} statements - collection of ASTNodes for the parent node block
-     * @returns {Boolean} True if var is on top otherwise false
-     */
-    function isVarOnTop(node, statements) {
-        var i = 0, l = statements.length;
-
-        // skip over directives
-        for (; i < l; ++i) {
-            if (!looksLikeDirective(statements[i]) && !looksLikeImport(statements[i])) {
-                break;
-            }
-        }
-
-        for (; i < l; ++i) {
-            if (statements[i].type !== "VariableDeclaration") {
-                return false;
-            }
-            if (statements[i] === node) {
-                return true;
-            }
-        }
-    }
-
-    /**
-     * Checks whether variable is on top at the global level
-     * @param {ASTNode} node - The node to check
-     * @param {ASTNode} parent - Parent of the node
-     * @returns {void}
-     */
-    function globalVarCheck(node, parent) {
-        if (!isVarOnTop(node, parent.body)) {
-            context.report(node, errorMessage);
-        }
-    }
-
-    /**
-     * Checks whether variable is on top at functional block scope level
-     * @param {ASTNode} node - The node to check
-     * @param {ASTNode} parent - Parent of the node
-     * @param {ASTNode} grandParent - Parent of the node's parent
-     * @returns {void}
-     */
-    function blockScopeVarCheck(node, parent, grandParent) {
-        if (!(/Function/.test(grandParent.type) &&
-                parent.type === "BlockStatement" &&
-                isVarOnTop(node, parent.body))) {
-            context.report(node, errorMessage);
-        }
-    }
-
-    //--------------------------------------------------------------------------
-    // Public API
-    //--------------------------------------------------------------------------
-
-    return {
-        "VariableDeclaration": function (node) {
-            var ancestors = context.getAncestors();
-            var parent = ancestors.pop();
-            var grandParent = ancestors.pop();
-
-            if (node.kind === "var") {// check variable is `var` type and not `let` or `const`
-                if (parent.type === "Program") {// That means its a global variable
-                    globalVarCheck(node, parent);
-                } else {
-                    blockScopeVarCheck(node, parent, grandParent);
-                }
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to enforce var declarations are only at the top of a function.
+ * @author Danny Fritz
+ * @author Gyandeep Singh
+ * @copyright 2014 Danny Fritz. All rights reserved.
+ * @copyright 2014 Gyandeep Singh. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function (context) {
+    var errorMessage = "All \"var\" declarations must be at the top of the function scope.";
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * @param {ASTNode} node - any node
+     * @returns {Boolean} whether the given node structurally represents a directive
+     */
+    function looksLikeDirective(node) {
+        return node.type === "ExpressionStatement" &&
+            node.expression.type === "Literal" && typeof node.expression.value === "string";
+    }
+
+    /**
+     * Check to see if its a ES6 import declaration
+     * @param {ASTNode} node - any node
+     * @returns {Boolean} whether the given node represents a import declaration
+     */
+    function looksLikeImport(node) {
+        return node.type === "ImportDeclaration" || node.type === "ImportSpecifier" ||
+            node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier";
+    }
+
+    /**
+     * Checks whether this variable is on top of the block body
+     * @param {ASTNode} node - The node to check
+     * @param {ASTNode[]} statements - collection of ASTNodes for the parent node block
+     * @returns {Boolean} True if var is on top otherwise false
+     */
+    function isVarOnTop(node, statements) {
+        var i = 0, l = statements.length;
+
+        // skip over directives
+        for (; i < l; ++i) {
+            if (!looksLikeDirective(statements[i]) && !looksLikeImport(statements[i])) {
+                break;
+            }
+        }
+
+        for (; i < l; ++i) {
+            if (statements[i].type !== "VariableDeclaration") {
+                return false;
+            }
+            if (statements[i] === node) {
+                return true;
+            }
+        }
+    }
+
+    /**
+     * Checks whether variable is on top at the global level
+     * @param {ASTNode} node - The node to check
+     * @param {ASTNode} parent - Parent of the node
+     * @returns {void}
+     */
+    function globalVarCheck(node, parent) {
+        if (!isVarOnTop(node, parent.body)) {
+            context.report(node, errorMessage);
+        }
+    }
+
+    /**
+     * Checks whether variable is on top at functional block scope level
+     * @param {ASTNode} node - The node to check
+     * @param {ASTNode} parent - Parent of the node
+     * @param {ASTNode} grandParent - Parent of the node's parent
+     * @returns {void}
+     */
+    function blockScopeVarCheck(node, parent, grandParent) {
+        if (!(/Function/.test(grandParent.type) &&
+                parent.type === "BlockStatement" &&
+                isVarOnTop(node, parent.body))) {
+            context.report(node, errorMessage);
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Public API
+    //--------------------------------------------------------------------------
+
+    return {
+        "VariableDeclaration": function (node) {
+            var ancestors = context.getAncestors();
+            var parent = ancestors.pop();
+            var grandParent = ancestors.pop();
+
+            if (node.kind === "var") {// check variable is `var` type and not `let` or `const`
+                if (parent.type === "Program") {// That means its a global variable
+                    globalVarCheck(node, parent);
+                } else {
+                    blockScopeVarCheck(node, parent, grandParent);
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/wrap-iife.js

@@ -1,48 +1,48 @@
-/**
- * @fileoverview Rule to flag when IIFE is not wrapped in parens
- * @author Ilya Volodin
- * @copyright 2013 Ilya Volodin. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var style = context.options[0] || "outside";
-
-    function wrapped(node) {
-        var previousToken = context.getTokenBefore(node),
-            nextToken = context.getTokenAfter(node);
-        return previousToken && previousToken.value === "(" &&
-            nextToken && nextToken.value === ")";
-    }
-
-    return {
-
-        "CallExpression": function(node) {
-            if (node.callee.type === "FunctionExpression") {
-                var callExpressionWrapped = wrapped(node),
-                    functionExpressionWrapped = wrapped(node.callee);
-
-                if (!callExpressionWrapped && !functionExpressionWrapped) {
-                    context.report(node, "Wrap an immediate function invocation in parentheses.");
-                } else if (style === "inside" && !functionExpressionWrapped) {
-                    context.report(node, "Wrap only the function expression in parens.");
-                } else if (style === "outside" && !callExpressionWrapped) {
-                    context.report(node, "Move the invocation into the parens that contain the function.");
-                }
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["outside", "inside", "any"]
-    }
-];
+/**
+ * @fileoverview Rule to flag when IIFE is not wrapped in parens
+ * @author Ilya Volodin
+ * @copyright 2013 Ilya Volodin. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var style = context.options[0] || "outside";
+
+    function wrapped(node) {
+        var previousToken = context.getTokenBefore(node),
+            nextToken = context.getTokenAfter(node);
+        return previousToken && previousToken.value === "(" &&
+            nextToken && nextToken.value === ")";
+    }
+
+    return {
+
+        "CallExpression": function(node) {
+            if (node.callee.type === "FunctionExpression") {
+                var callExpressionWrapped = wrapped(node),
+                    functionExpressionWrapped = wrapped(node.callee);
+
+                if (!callExpressionWrapped && !functionExpressionWrapped) {
+                    context.report(node, "Wrap an immediate function invocation in parentheses.");
+                } else if (style === "inside" && !functionExpressionWrapped) {
+                    context.report(node, "Wrap only the function expression in parens.");
+                } else if (style === "outside" && !callExpressionWrapped) {
+                    context.report(node, "Move the invocation into the parens that contain the function.");
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["outside", "inside", "any"]
+    }
+];

package/lib/rules/wrap-regex.js

@@ -1,38 +1,38 @@
-/**
- * @fileoverview Rule to flag when regex literals are not wrapped in parens
- * @author Matt DuVall <http://www.mattduvall.com>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "Literal": function(node) {
-            var token = context.getFirstToken(node),
-                nodeType = token.type,
-                source,
-                grandparent,
-                ancestors;
-
-            if (nodeType === "RegularExpression") {
-                source = context.getTokenBefore(node);
-                ancestors = context.getAncestors();
-                grandparent = ancestors[ancestors.length - 1];
-
-                if (grandparent.type === "MemberExpression" && grandparent.object === node &&
-                    (!source || source.value !== "(")) {
-                    context.report(node, "Wrap the regexp literal in parens to disambiguate the slash.");
-                }
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag when regex literals are not wrapped in parens
+ * @author Matt DuVall <http://www.mattduvall.com>
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "Literal": function(node) {
+            var token = context.getFirstToken(node),
+                nodeType = token.type,
+                source,
+                grandparent,
+                ancestors;
+
+            if (nodeType === "RegularExpression") {
+                source = context.getTokenBefore(node);
+                ancestors = context.getAncestors();
+                grandparent = ancestors[ancestors.length - 1];
+
+                if (grandparent.type === "MemberExpression" && grandparent.object === node &&
+                    (!source || source.value !== "(")) {
+                    context.report(node, "Wrap the regexp literal in parens to disambiguate the slash.");
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];