eslint 0.22.0 → 0.24.1

package/lib/rules/no-bitwise.js

@@ -1,57 +1,57 @@
-/**
- * @fileoverview Rule to flag bitwise identifiers
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var BITWISE_OPERATORS = [
-        "^", "|", "&", "<<", ">>", ">>>",
-        "^=", "|=", "&=", "<<=", ">>=", ">>>=",
-        "~"
-    ];
-
-    /**
-     * Reports an unexpected use of a bitwise operator.
-     * @param   {ASTNode} node Node which contains the bitwise operator.
-     * @returns {void}
-     */
-    function report(node) {
-        context.report(node, "Unexpected use of '{{operator}}'.", { operator: node.operator });
-    }
-
-    /**
-     * Checks if the given node has a bitwise operator.
-     * @param   {ASTNode} node The node to check.
-     * @returns {boolean} Whether or not the node has a bitwise operator.
-     */
-    function hasBitwiseOperator(node) {
-        return BITWISE_OPERATORS.indexOf(node.operator) !== -1;
-    }
-
-    /**
-     * Report if the given node contains a bitwise operator.
-     * @param {ASTNode} node The node to check.
-     * @returns {void}
-     */
-    function checkNodeForBitwiseOperator(node) {
-        if (hasBitwiseOperator(node)) {
-            report(node);
-        }
-    }
-
-    return {
-        "AssignmentExpression": checkNodeForBitwiseOperator,
-        "BinaryExpression": checkNodeForBitwiseOperator,
-        "UnaryExpression": checkNodeForBitwiseOperator
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag bitwise identifiers
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var BITWISE_OPERATORS = [
+        "^", "|", "&", "<<", ">>", ">>>",
+        "^=", "|=", "&=", "<<=", ">>=", ">>>=",
+        "~"
+    ];
+
+    /**
+     * Reports an unexpected use of a bitwise operator.
+     * @param   {ASTNode} node Node which contains the bitwise operator.
+     * @returns {void}
+     */
+    function report(node) {
+        context.report(node, "Unexpected use of '{{operator}}'.", { operator: node.operator });
+    }
+
+    /**
+     * Checks if the given node has a bitwise operator.
+     * @param   {ASTNode} node The node to check.
+     * @returns {boolean} Whether or not the node has a bitwise operator.
+     */
+    function hasBitwiseOperator(node) {
+        return BITWISE_OPERATORS.indexOf(node.operator) !== -1;
+    }
+
+    /**
+     * Report if the given node contains a bitwise operator.
+     * @param {ASTNode} node The node to check.
+     * @returns {void}
+     */
+    function checkNodeForBitwiseOperator(node) {
+        if (hasBitwiseOperator(node)) {
+            report(node);
+        }
+    }
+
+    return {
+        "AssignmentExpression": checkNodeForBitwiseOperator,
+        "BinaryExpression": checkNodeForBitwiseOperator,
+        "UnaryExpression": checkNodeForBitwiseOperator
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-caller.js

@@ -1,29 +1,29 @@
-/**
- * @fileoverview Rule to flag use of arguments.callee and arguments.caller.
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "MemberExpression": function(node) {
-            var objectName = node.object.name,
-                propertyName = node.property.name;
-
-            if (objectName === "arguments" && !node.computed && propertyName && propertyName.match(/^calle[er]$/)) {
-                context.report(node, "Avoid arguments.{{property}}.", { property: propertyName });
-            }
-
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of arguments.callee and arguments.caller.
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "MemberExpression": function(node) {
+            var objectName = node.object.name,
+                propertyName = node.property.name;
+
+            if (objectName === "arguments" && !node.computed && propertyName && propertyName.match(/^calle[er]$/)) {
+                context.report(node, "Avoid arguments.{{property}}.", { property: propertyName });
+            }
+
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-catch-shadow.js

@@ -1,52 +1,52 @@
-/**
- * @fileoverview Rule to flag variable leak in CatchClauses in IE 8 and earlier
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    function paramIsShadowing(scope, name) {
-        var found = scope.variables.some(function(variable) {
-            return variable.name === name;
-        });
-
-        if (found) {
-            return true;
-        }
-
-        if (scope.upper) {
-            return paramIsShadowing(scope.upper, name);
-        }
-
-        return false;
-    }
-
-    //--------------------------------------------------------------------------
-    // Public API
-    //--------------------------------------------------------------------------
-
-    return {
-
-        "CatchClause": function(node) {
-            var scope = context.getScope();
-
-            if (paramIsShadowing(scope, node.param.name)) {
-                context.report(node, "Value of '{{name}}' may be overwritten in IE 8 and earlier.",
-                        { name: node.param.name });
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag variable leak in CatchClauses in IE 8 and earlier
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    function paramIsShadowing(scope, name) {
+        var found = scope.variables.some(function(variable) {
+            return variable.name === name;
+        });
+
+        if (found) {
+            return true;
+        }
+
+        if (scope.upper) {
+            return paramIsShadowing(scope.upper, name);
+        }
+
+        return false;
+    }
+
+    //--------------------------------------------------------------------------
+    // Public API
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "CatchClause": function(node) {
+            var scope = context.getScope();
+
+            if (paramIsShadowing(scope, node.param.name)) {
+                context.report(node, "Value of '{{name}}' may be overwritten in IE 8 and earlier.",
+                        { name: node.param.name });
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-comma-dangle.js

@@ -1,45 +1,45 @@
-/**
- * @fileoverview Rule to flag trailing commas in object literals.
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-     //-------------------------------------------------------------------------
-     // Helpers
-     //-------------------------------------------------------------------------
-
-    function checkForTrailingComma(node) {
-        var items = node.properties || node.elements,
-            length = items.length,
-            lastItem, penultimateToken;
-
-        if (length) {
-            lastItem = items[length - 1];
-            if (lastItem) {
-                penultimateToken = context.getLastToken(node, 1);
-                if (penultimateToken.value === ",") {
-                    context.report(lastItem, penultimateToken.loc.start, "Trailing comma.");
-                }
-            }
-        }
-    }
-
-    //--------------------------------------------------------------------------
-    // Public API
-    //--------------------------------------------------------------------------
-
-    return {
-        "ObjectExpression": checkForTrailingComma,
-        "ArrayExpression": checkForTrailingComma
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag trailing commas in object literals.
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+     //-------------------------------------------------------------------------
+     // Helpers
+     //-------------------------------------------------------------------------
+
+    function checkForTrailingComma(node) {
+        var items = node.properties || node.elements,
+            length = items.length,
+            lastItem, penultimateToken;
+
+        if (length) {
+            lastItem = items[length - 1];
+            if (lastItem) {
+                penultimateToken = context.getLastToken(node, 1);
+                if (penultimateToken.value === ",") {
+                    context.report(lastItem, penultimateToken.loc.start, "Trailing comma.");
+                }
+            }
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Public API
+    //--------------------------------------------------------------------------
+
+    return {
+        "ObjectExpression": checkForTrailingComma,
+        "ArrayExpression": checkForTrailingComma
+    };
+
+};
+
+module.exports.schema = [];

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

@@ -1,123 +1,123 @@
-/**
- * @fileoverview Rule to flag assignment in a conditional statement's test expression
- * @author Stephen Murray <spmurrayzzz>
- */
-"use strict";
-
-var NODE_DESCRIPTIONS = {
-    "DoWhileStatement": "a 'do...while' statement",
-    "ForStatement": "a 'for' statement",
-    "IfStatement": "an 'if' statement",
-    "WhileStatement": "a 'while' statement"
-};
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var prohibitAssign = (context.options[0] || "except-parens");
-
-    /**
-     * Check whether an AST node is the test expression for a conditional statement.
-     * @param {!Object} node The node to test.
-     * @returns {boolean} `true` if the node is the text expression for a conditional statement; otherwise, `false`.
-     */
-    function isConditionalTestExpression(node) {
-        return node.parent &&
-            node.parent.test &&
-            node === node.parent.test;
-    }
-
-    /**
-     * Given an AST node, perform a bottom-up search for the first ancestor that represents a conditional statement.
-     * @param {!Object} node The node to use at the start of the search.
-     * @returns {?Object} The closest ancestor node that represents a conditional statement.
-     */
-    function findConditionalAncestor(node) {
-        var currentAncestor = node;
-
-        while ((currentAncestor = currentAncestor.parent)) {
-            if (isConditionalTestExpression(currentAncestor)) {
-                return currentAncestor.parent;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Check whether the code represented by an AST node is enclosed in parentheses.
-     * @param {!Object} node The node to test.
-     * @returns {boolean} `true` if the code is enclosed in parentheses; otherwise, `false`.
-     */
-    function isParenthesised(node) {
-        var previousToken = context.getTokenBefore(node),
-            nextToken = context.getTokenAfter(node);
-
-        return previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
-            nextToken.value === ")" && nextToken.range[0] >= node.range[1];
-    }
-
-    /**
-     * Check whether the code represented by an AST node is enclosed in two sets of parentheses.
-     * @param {!Object} node The node to test.
-     * @returns {boolean} `true` if the code is enclosed in two sets of parentheses; otherwise, `false`.
-     */
-    function isParenthesisedTwice(node) {
-        var previousToken = context.getTokenBefore(node, 1),
-            nextToken = context.getTokenAfter(node, 1);
-
-        return isParenthesised(node) &&
-            previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
-            nextToken.value === ")" && nextToken.range[0] >= node.range[1];
-    }
-
-    /**
-     * Check a conditional statement's test expression for top-level assignments that are not enclosed in parentheses.
-     * @param {!Object} node The node for the conditional statement.
-     * @returns {void}
-     */
-    function testForAssign(node) {
-        if (node.test && (node.test.type === "AssignmentExpression") && !isParenthesisedTwice(node.test)) {
-            // must match JSHint's error message
-            context.report(node, "Expected a conditional expression and instead saw an assignment.");
-        }
-    }
-
-    /**
-     * Check whether an assignment expression is descended from a conditional statement's test expression.
-     * @param {!Object} node The node for the assignment expression.
-     * @returns {void}
-     */
-    function testForConditionalAncestor(node) {
-        var ancestor = findConditionalAncestor(node);
-
-        if (ancestor) {
-            context.report(ancestor, "Unexpected assignment within {{type}}.", {
-                type: NODE_DESCRIPTIONS[ancestor.type] || ancestor.type
-            });
-        }
-    }
-
-    if (prohibitAssign === "always") {
-        return {
-            "AssignmentExpression": testForConditionalAncestor
-        };
-    }
-
-    return {
-        "DoWhileStatement": testForAssign,
-        "ForStatement": testForAssign,
-        "IfStatement": testForAssign,
-        "WhileStatement": testForAssign
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["except-parens", "always"]
-    }
-];
+/**
+ * @fileoverview Rule to flag assignment in a conditional statement's test expression
+ * @author Stephen Murray <spmurrayzzz>
+ */
+"use strict";
+
+var NODE_DESCRIPTIONS = {
+    "DoWhileStatement": "a 'do...while' statement",
+    "ForStatement": "a 'for' statement",
+    "IfStatement": "an 'if' statement",
+    "WhileStatement": "a 'while' statement"
+};
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var prohibitAssign = (context.options[0] || "except-parens");
+
+    /**
+     * Check whether an AST node is the test expression for a conditional statement.
+     * @param {!Object} node The node to test.
+     * @returns {boolean} `true` if the node is the text expression for a conditional statement; otherwise, `false`.
+     */
+    function isConditionalTestExpression(node) {
+        return node.parent &&
+            node.parent.test &&
+            node === node.parent.test;
+    }
+
+    /**
+     * Given an AST node, perform a bottom-up search for the first ancestor that represents a conditional statement.
+     * @param {!Object} node The node to use at the start of the search.
+     * @returns {?Object} The closest ancestor node that represents a conditional statement.
+     */
+    function findConditionalAncestor(node) {
+        var currentAncestor = node;
+
+        while ((currentAncestor = currentAncestor.parent)) {
+            if (isConditionalTestExpression(currentAncestor)) {
+                return currentAncestor.parent;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Check whether the code represented by an AST node is enclosed in parentheses.
+     * @param {!Object} node The node to test.
+     * @returns {boolean} `true` if the code is enclosed in parentheses; otherwise, `false`.
+     */
+    function isParenthesised(node) {
+        var previousToken = context.getTokenBefore(node),
+            nextToken = context.getTokenAfter(node);
+
+        return previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
+            nextToken.value === ")" && nextToken.range[0] >= node.range[1];
+    }
+
+    /**
+     * Check whether the code represented by an AST node is enclosed in two sets of parentheses.
+     * @param {!Object} node The node to test.
+     * @returns {boolean} `true` if the code is enclosed in two sets of parentheses; otherwise, `false`.
+     */
+    function isParenthesisedTwice(node) {
+        var previousToken = context.getTokenBefore(node, 1),
+            nextToken = context.getTokenAfter(node, 1);
+
+        return isParenthesised(node) &&
+            previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
+            nextToken.value === ")" && nextToken.range[0] >= node.range[1];
+    }
+
+    /**
+     * Check a conditional statement's test expression for top-level assignments that are not enclosed in parentheses.
+     * @param {!Object} node The node for the conditional statement.
+     * @returns {void}
+     */
+    function testForAssign(node) {
+        if (node.test && (node.test.type === "AssignmentExpression") && !isParenthesisedTwice(node.test)) {
+            // must match JSHint's error message
+            context.report(node, "Expected a conditional expression and instead saw an assignment.");
+        }
+    }
+
+    /**
+     * Check whether an assignment expression is descended from a conditional statement's test expression.
+     * @param {!Object} node The node for the assignment expression.
+     * @returns {void}
+     */
+    function testForConditionalAncestor(node) {
+        var ancestor = findConditionalAncestor(node);
+
+        if (ancestor) {
+            context.report(ancestor, "Unexpected assignment within {{type}}.", {
+                type: NODE_DESCRIPTIONS[ancestor.type] || ancestor.type
+            });
+        }
+    }
+
+    if (prohibitAssign === "always") {
+        return {
+            "AssignmentExpression": testForConditionalAncestor
+        };
+    }
+
+    return {
+        "DoWhileStatement": testForAssign,
+        "ForStatement": testForAssign,
+        "IfStatement": testForAssign,
+        "WhileStatement": testForAssign
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["except-parens", "always"]
+    }
+];

package/lib/rules/no-console.js

@@ -1,27 +1,27 @@
-/**
- * @fileoverview Rule to flag use of console object
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "MemberExpression": function(node) {
-
-            if (node.object.name === "console") {
-                context.report(node, "Unexpected console statement.");
-            }
-
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of console object
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "MemberExpression": function(node) {
+
+            if (node.object.name === "console") {
+                context.report(node, "Unexpected console statement.");
+            }
+
+        }
+    };
+
+};
+
+module.exports.schema = [];