eslint 0.22.0 → 0.24.1

package/lib/rules/no-self-compare.js

@@ -1,29 +1,29 @@
-/**
- * @fileoverview Rule to flag comparison where left part is the same as the right
- * part.
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "BinaryExpression": function(node) {
-            var operators = ["===", "==", "!==", "!=", ">", "<", ">=", "<="];
-            if (operators.indexOf(node.operator) > -1 &&
-                (node.left.type === "Identifier" && node.right.type === "Identifier" && node.left.name === node.right.name ||
-                node.left.type === "Literal" && node.right.type === "Literal" && node.left.value === node.right.value)) {
-                context.report(node, "Comparing to itself is potentially pointless.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag comparison where left part is the same as the right
+ * part.
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "BinaryExpression": function(node) {
+            var operators = ["===", "==", "!==", "!=", ">", "<", ">=", "<="];
+            if (operators.indexOf(node.operator) > -1 &&
+                (node.left.type === "Identifier" && node.right.type === "Identifier" && node.left.name === node.right.name ||
+                node.left.type === "Literal" && node.right.type === "Literal" && node.left.value === node.right.value)) {
+                context.report(node, "Comparing to itself is potentially pointless.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-sequences.js

@@ -1,94 +1,94 @@
-/**
- * @fileoverview Rule to flag use of comma operator
- * @author Brandon Mills
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * Parts of the grammar that are required to have parens.
-     */
-    var parenthesized = {
-        "DoWhileStatement": "test",
-        "IfStatement": "test",
-        "SwitchStatement": "discriminant",
-        "WhileStatement": "test",
-        "WithStatement": "object"
-
-        // Omitting CallExpression - commas are parsed as argument separators
-        // Omitting NewExpression - commas are parsed as argument separators
-        // Omitting ForInStatement - parts aren't individually parenthesised
-        // Omitting ForStatement - parts aren't individually parenthesised
-    };
-
-    /**
-     * Determines whether a node is required by the grammar to be wrapped in
-     * parens, e.g. the test of an if statement.
-     * @param {ASTNode} node - The AST node
-     * @returns {boolean} True if parens around node belong to parent node.
-     */
-    function requiresExtraParens(node) {
-        return node.parent && parenthesized[node.parent.type] != null &&
-                node === node.parent[parenthesized[node.parent.type]];
-    }
-
-    /**
-     * Check if a node is wrapped in parens.
-     * @param {ASTNode} node - The AST node
-     * @returns {boolean} True if the node has a paren on each side.
-     */
-    function isParenthesised(node) {
-        var previousToken = context.getTokenBefore(node),
-            nextToken = context.getTokenAfter(node);
-
-        return previousToken && nextToken &&
-            previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
-            nextToken.value === ")" && nextToken.range[0] >= node.range[1];
-    }
-
-    /**
-     * Check if a node is wrapped in two levels of parens.
-     * @param {ASTNode} node - The AST node
-     * @returns {boolean} True if two parens surround the node on each side.
-     */
-    function isParenthesisedTwice(node) {
-        var previousToken = context.getTokenBefore(node, 1),
-            nextToken = context.getTokenAfter(node, 1);
-
-        return isParenthesised(node) && previousToken && nextToken &&
-            previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
-            nextToken.value === ")" && nextToken.range[0] >= node.range[1];
-    }
-
-    return {
-        "SequenceExpression": function(node) {
-            // Always allow sequences in for statement update
-            if (node.parent.type === "ForStatement" &&
-                    (node === node.parent.init || node === node.parent.update)) {
-                return;
-            }
-
-            // Wrapping a sequence in extra parens indicates intent
-            if (requiresExtraParens(node)) {
-                if (isParenthesisedTwice(node)) {
-                    return;
-                }
-            } else {
-                if (isParenthesised(node)) {
-                    return;
-                }
-            }
-
-            context.report(node, "Unexpected use of comma operator.");
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of comma operator
+ * @author Brandon Mills
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Parts of the grammar that are required to have parens.
+     */
+    var parenthesized = {
+        "DoWhileStatement": "test",
+        "IfStatement": "test",
+        "SwitchStatement": "discriminant",
+        "WhileStatement": "test",
+        "WithStatement": "object"
+
+        // Omitting CallExpression - commas are parsed as argument separators
+        // Omitting NewExpression - commas are parsed as argument separators
+        // Omitting ForInStatement - parts aren't individually parenthesised
+        // Omitting ForStatement - parts aren't individually parenthesised
+    };
+
+    /**
+     * Determines whether a node is required by the grammar to be wrapped in
+     * parens, e.g. the test of an if statement.
+     * @param {ASTNode} node - The AST node
+     * @returns {boolean} True if parens around node belong to parent node.
+     */
+    function requiresExtraParens(node) {
+        return node.parent && parenthesized[node.parent.type] != null &&
+                node === node.parent[parenthesized[node.parent.type]];
+    }
+
+    /**
+     * Check if a node is wrapped in parens.
+     * @param {ASTNode} node - The AST node
+     * @returns {boolean} True if the node has a paren on each side.
+     */
+    function isParenthesised(node) {
+        var previousToken = context.getTokenBefore(node),
+            nextToken = context.getTokenAfter(node);
+
+        return previousToken && nextToken &&
+            previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
+            nextToken.value === ")" && nextToken.range[0] >= node.range[1];
+    }
+
+    /**
+     * Check if a node is wrapped in two levels of parens.
+     * @param {ASTNode} node - The AST node
+     * @returns {boolean} True if two parens surround the node on each side.
+     */
+    function isParenthesisedTwice(node) {
+        var previousToken = context.getTokenBefore(node, 1),
+            nextToken = context.getTokenAfter(node, 1);
+
+        return isParenthesised(node) && previousToken && nextToken &&
+            previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
+            nextToken.value === ")" && nextToken.range[0] >= node.range[1];
+    }
+
+    return {
+        "SequenceExpression": function(node) {
+            // Always allow sequences in for statement update
+            if (node.parent.type === "ForStatement" &&
+                    (node === node.parent.init || node === node.parent.update)) {
+                return;
+            }
+
+            // Wrapping a sequence in extra parens indicates intent
+            if (requiresExtraParens(node)) {
+                if (isParenthesisedTwice(node)) {
+                    return;
+                }
+            } else {
+                if (isParenthesised(node)) {
+                    return;
+                }
+            }
+
+            context.report(node, "Unexpected use of comma operator.");
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-shadow-restricted-names.js

@@ -1,51 +1,51 @@
-/**
- * @fileoverview Disallow shadowing of NaN, undefined, and Infinity (ES5 section 15.1.1)
- * @author Michael Ficarra
- * @copyright 2013 Michael Ficarra. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var RESTRICTED = ["undefined", "NaN", "Infinity", "arguments", "eval"];
-
-    function checkForViolation(id) {
-        if (RESTRICTED.indexOf(id.name) > -1) {
-            context.report(id, "Shadowing of global property \"" + id.name + "\".");
-        }
-    }
-
-    return {
-        "VariableDeclarator": function(node) {
-            checkForViolation(node.id);
-        },
-        "ArrowFunctionExpression": function(node) {
-            if (node.id) {
-                checkForViolation(node.id);
-            }
-            [].map.call(node.params, checkForViolation);
-        },
-        "FunctionExpression": function(node) {
-            if (node.id) {
-                checkForViolation(node.id);
-            }
-            [].map.call(node.params, checkForViolation);
-        },
-        "FunctionDeclaration": function(node) {
-            if (node.id) {
-                checkForViolation(node.id);
-                [].map.call(node.params, checkForViolation);
-            }
-        },
-        "CatchClause": function(node) {
-            checkForViolation(node.param);
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Disallow shadowing of NaN, undefined, and Infinity (ES5 section 15.1.1)
+ * @author Michael Ficarra
+ * @copyright 2013 Michael Ficarra. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var RESTRICTED = ["undefined", "NaN", "Infinity", "arguments", "eval"];
+
+    function checkForViolation(id) {
+        if (RESTRICTED.indexOf(id.name) > -1) {
+            context.report(id, "Shadowing of global property \"" + id.name + "\".");
+        }
+    }
+
+    return {
+        "VariableDeclarator": function(node) {
+            checkForViolation(node.id);
+        },
+        "ArrowFunctionExpression": function(node) {
+            if (node.id) {
+                checkForViolation(node.id);
+            }
+            [].map.call(node.params, checkForViolation);
+        },
+        "FunctionExpression": function(node) {
+            if (node.id) {
+                checkForViolation(node.id);
+            }
+            [].map.call(node.params, checkForViolation);
+        },
+        "FunctionDeclaration": function(node) {
+            if (node.id) {
+                checkForViolation(node.id);
+                [].map.call(node.params, checkForViolation);
+            }
+        },
+        "CatchClause": function(node) {
+            checkForViolation(node.param);
+        }
+    };
+
+};
+
+module.exports.schema = [];