eslint 0.22.0 → 0.24.1

package/lib/rules/no-constant-condition.js

@@ -1,73 +1,73 @@
-/**
- * @fileoverview Rule to flag use constant conditions
- * @author Christian Schulz <http://rndm.de>
- * @copyright 2014 Christian Schulz. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /**
-     * Checks if a node has a constant truthiness value.
-     * @param {ASTNode} node The AST node to check.
-     * @returns {Bool} true when node's truthiness is constant
-     * @private
-     */
-    function isConstant(node) {
-        switch (node.type) {
-            case "Literal":
-            case "ArrowFunctionExpression":
-            case "FunctionExpression":
-            case "ObjectExpression":
-            case "ArrayExpression":
-                return true;
-            case "UnaryExpression":
-                return isConstant(node.argument);
-            case "BinaryExpression":
-            case "LogicalExpression":
-                return isConstant(node.left) && isConstant(node.right);
-            case "AssignmentExpression":
-                return (node.operator === "=") && isConstant(node.right);
-            case "SequenceExpression":
-                return isConstant(node.expressions[node.expressions.length - 1]);
-            // no default
-        }
-        return false;
-    }
-
-    /**
-     * Reports when the given node contains a constant condition.
-     * @param {ASTNode} node The AST node to check.
-     * @returns {void}
-     * @private
-     */
-    function checkConstantCondition(node) {
-        if (node.test && isConstant(node.test)) {
-            context.report(node, "Unexpected constant condition.");
-        }
-    }
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    return {
-        "ConditionalExpression": checkConstantCondition,
-        "IfStatement": checkConstantCondition,
-        "WhileStatement": checkConstantCondition,
-        "DoWhileStatement": checkConstantCondition,
-        "ForStatement": checkConstantCondition
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use constant conditions
+ * @author Christian Schulz <http://rndm.de>
+ * @copyright 2014 Christian Schulz. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Checks if a node has a constant truthiness value.
+     * @param {ASTNode} node The AST node to check.
+     * @returns {Bool} true when node's truthiness is constant
+     * @private
+     */
+    function isConstant(node) {
+        switch (node.type) {
+            case "Literal":
+            case "ArrowFunctionExpression":
+            case "FunctionExpression":
+            case "ObjectExpression":
+            case "ArrayExpression":
+                return true;
+            case "UnaryExpression":
+                return isConstant(node.argument);
+            case "BinaryExpression":
+            case "LogicalExpression":
+                return isConstant(node.left) && isConstant(node.right);
+            case "AssignmentExpression":
+                return (node.operator === "=") && isConstant(node.right);
+            case "SequenceExpression":
+                return isConstant(node.expressions[node.expressions.length - 1]);
+            // no default
+        }
+        return false;
+    }
+
+    /**
+     * Reports when the given node contains a constant condition.
+     * @param {ASTNode} node The AST node to check.
+     * @returns {void}
+     * @private
+     */
+    function checkConstantCondition(node) {
+        if (node.test && isConstant(node.test)) {
+            context.report(node, "Unexpected constant condition.");
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+        "ConditionalExpression": checkConstantCondition,
+        "IfStatement": checkConstantCondition,
+        "WhileStatement": checkConstantCondition,
+        "DoWhileStatement": checkConstantCondition,
+        "ForStatement": checkConstantCondition
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-continue.js

@@ -1,23 +1,23 @@
-/**
- * @fileoverview Rule to flag use of continue statement
- * @author Borislav Zhivkov
- * @copyright 2015 Borislav Zhivkov. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-        "ContinueStatement": function(node) {
-            context.report(node, "Unexpected use of continue statement");
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of continue statement
+ * @author Borislav Zhivkov
+ * @copyright 2015 Borislav Zhivkov. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+        "ContinueStatement": function(node) {
+            context.report(node, "Unexpected use of continue statement");
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-control-regex.js

@@ -1,58 +1,58 @@
-/**
- * @fileoverview Rule to forbid control charactes from regular expressions.
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    function getRegExp(node) {
-
-        if (node.value instanceof RegExp) {
-            return node.value;
-        } else if (typeof node.value === "string") {
-
-            var parent = context.getAncestors().pop();
-            if ((parent.type === "NewExpression" || parent.type === "CallExpression") &&
-            parent.callee.type === "Identifier" && parent.callee.name === "RegExp") {
-
-                // there could be an invalid regular expression string
-                try {
-                    return new RegExp(node.value);
-                } catch (ex) {
-                    return null;
-                }
-
-            }
-        } else {
-            return null;
-        }
-
-    }
-
-
-
-    return {
-
-        "Literal": function(node) {
-
-            var computedValue,
-                regex = getRegExp(node);
-
-            if (regex) {
-                computedValue = regex.toString();
-                if (/[\x00-\x1f]/.test(computedValue)) {
-                    context.report(node, "Unexpected control character in regular expression.");
-                }
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to forbid control charactes from regular expressions.
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    function getRegExp(node) {
+
+        if (node.value instanceof RegExp) {
+            return node.value;
+        } else if (typeof node.value === "string") {
+
+            var parent = context.getAncestors().pop();
+            if ((parent.type === "NewExpression" || parent.type === "CallExpression") &&
+            parent.callee.type === "Identifier" && parent.callee.name === "RegExp") {
+
+                // there could be an invalid regular expression string
+                try {
+                    return new RegExp(node.value);
+                } catch (ex) {
+                    return null;
+                }
+
+            }
+        } else {
+            return null;
+        }
+
+    }
+
+
+
+    return {
+
+        "Literal": function(node) {
+
+            var computedValue,
+                regex = getRegExp(node);
+
+            if (regex) {
+                computedValue = regex.toString();
+                if (/[\x00-\x1f]/.test(computedValue)) {
+                    context.report(node, "Unexpected control character in regular expression.");
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-debugger.js

@@ -1,22 +1,22 @@
-/**
- * @fileoverview Rule to flag use of a debugger statement
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-        "DebuggerStatement": function(node) {
-            context.report(node, "Unexpected 'debugger' statement.");
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of a debugger statement
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+        "DebuggerStatement": function(node) {
+            context.report(node, "Unexpected 'debugger' statement.");
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-delete-var.js

@@ -1,25 +1,25 @@
-/**
- * @fileoverview Rule to flag when deleting variables
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "UnaryExpression": function(node) {
-            if (node.operator === "delete" && node.argument.type === "Identifier") {
-                context.report(node, "Variables should not be deleted.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag when deleting variables
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "UnaryExpression": function(node) {
+            if (node.operator === "delete" && node.argument.type === "Identifier") {
+                context.report(node, "Variables should not be deleted.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-div-regex.js

@@ -1,27 +1,27 @@
-/**
- * @fileoverview Rule to check for ambiguous div operator in regexes
- * @author Matt DuVall <http://www.mattduvall.com>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "Literal": function(node) {
-            var token = context.getFirstToken(node);
-
-            if (token.type === "RegularExpression" && token.value[1] === "=") {
-                context.report(node, "A regular expression literal can be confused with '/='.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to check for ambiguous div operator in regexes
+ * @author Matt DuVall <http://www.mattduvall.com>
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "Literal": function(node) {
+            var token = context.getFirstToken(node);
+
+            if (token.type === "RegularExpression" && token.value[1] === "=") {
+                context.report(node, "A regular expression literal can be confused with '/='.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-dupe-args.js

@@ -1,85 +1,89 @@
-/**
- * @fileoverview Rule to flag duplicate arguments
- * @author Jamund Ferguson
- * @copyright 2015 Jamund Ferguson. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /**
-     * Determines if a given node has duplicate parameters.
-     * @param {ASTNode} node The node to check.
-     * @returns {void}
-     * @private
-     */
-    function checkParams(node) {
-        var params = {},
-            dups = {};
-
-
-        /**
-         * Marks a given param as either seen or duplicated.
-         * @param {string} name The name of the param to mark.
-         * @returns {void}
-         * @private
-         */
-        function markParam(name) {
-            if (params.hasOwnProperty(name)) {
-                dups[name] = 1;
-            } else {
-                params[name] = 1;
-            }
-        }
-
-        // loop through and find each duplicate param
-        node.params.forEach(function(param) {
-
-            switch (param.type) {
-                case "Identifier":
-                    markParam(param.name);
-                    break;
-
-                case "ObjectPattern":
-                    param.properties.forEach(function(property) {
-                        markParam(property.key.name);
-                    });
-                    break;
-
-                case "ArrayPattern":
-                    param.elements.forEach(function(element) {
-                        markParam(element.name);
-                    });
-                    break;
-
-                // no default
-            }
-        });
-
-        // log an error for each duplicate (not 2 for each)
-        Object.keys(dups).forEach(function(currentParam) {
-            context.report(node, "Duplicate param '{{key}}'.", { key: currentParam });
-        });
-    }
-
-    //--------------------------------------------------------------------------
-    // Public API
-    //--------------------------------------------------------------------------
-
-    return {
-        "FunctionDeclaration": checkParams,
-        "FunctionExpression": checkParams
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag duplicate arguments
+ * @author Jamund Ferguson
+ * @copyright 2015 Jamund Ferguson. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Determines if a given node has duplicate parameters.
+     * @param {ASTNode} node The node to check.
+     * @returns {void}
+     * @private
+     */
+    function checkParams(node) {
+        var params = {},
+            dups = {};
+
+
+        /**
+         * Marks a given param as either seen or duplicated.
+         * @param {string} name The name of the param to mark.
+         * @returns {void}
+         * @private
+         */
+        function markParam(name) {
+            if (params.hasOwnProperty(name)) {
+                dups[name] = 1;
+            } else {
+                params[name] = 1;
+            }
+        }
+
+        // loop through and find each duplicate param
+        node.params.forEach(function(param) {
+
+            switch (param.type) {
+                case "Identifier":
+                    markParam(param.name);
+                    break;
+
+                case "ObjectPattern":
+                    param.properties.forEach(function(property) {
+                        markParam(property.key.name);
+                    });
+                    break;
+
+                case "ArrayPattern":
+                    param.elements.forEach(function(element) {
+
+                        // Arrays can be sparse (unwanted arguments)
+                        if (element !== null) {
+                            markParam(element.name);
+                        }
+                    });
+                    break;
+
+                // no default
+            }
+        });
+
+        // log an error for each duplicate (not 2 for each)
+        Object.keys(dups).forEach(function(currentParam) {
+            context.report(node, "Duplicate param '{{key}}'.", { key: currentParam });
+        });
+    }
+
+    //--------------------------------------------------------------------------
+    // Public API
+    //--------------------------------------------------------------------------
+
+    return {
+        "FunctionDeclaration": checkParams,
+        "FunctionExpression": checkParams
+    };
+
+};
+
+module.exports.schema = [];