eslint 0.22.0 → 0.24.1

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

@@ -1,43 +1,43 @@
-/**
- * @fileoverview Rule to flag use of duplicate keys in an object.
- * @author Ian Christian Myers
- * @copyright 2013 Ian Christian Myers. All rights reserved.
- * @copyright 2013 Nicholas C. Zakas. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "ObjectExpression": function(node) {
-
-            // Object that will be a map of properties--safe because we will
-            // prefix all of the keys.
-            var nodeProps = Object.create(null);
-
-            node.properties.forEach(function(property) {
-                var keyName = property.key.name || property.key.value,
-                    key = property.kind + "-" + keyName,
-                    checkProperty = (!property.computed || property.key.type === "Literal");
-
-                if (checkProperty) {
-                    if (nodeProps[key]) {
-                        context.report(node, "Duplicate key '{{key}}'.", { key: keyName });
-                    } else {
-                        nodeProps[key] = true;
-                    }
-                }
-            });
-
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of duplicate keys in an object.
+ * @author Ian Christian Myers
+ * @copyright 2013 Ian Christian Myers. All rights reserved.
+ * @copyright 2013 Nicholas C. Zakas. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "ObjectExpression": function(node) {
+
+            // Object that will be a map of properties--safe because we will
+            // prefix all of the keys.
+            var nodeProps = Object.create(null);
+
+            node.properties.forEach(function(property) {
+                var keyName = property.key.name || property.key.value,
+                    key = property.kind + "-" + keyName,
+                    checkProperty = (!property.computed || property.key.type === "Literal");
+
+                if (checkProperty) {
+                    if (nodeProps[key]) {
+                        context.report(node, "Duplicate key '{{key}}'.", { key: keyName });
+                    } else {
+                        nodeProps[key] = true;
+                    }
+                }
+            });
+
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-duplicate-case.js

@@ -1,67 +1,67 @@
-/**
- * @fileoverview Rule to disallow a duplicate case label.
- * @author Dieter Oberkofler
- * @copyright 2015 Dieter Oberkofler. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * Get a hash value for the node
-     * @param {ASTNode} node The node.
-     * @returns {string} A hash value for the node.
-     * @private
-     */
-    function getHash(node) {
-        if (node.type === "Literal") {
-            return node.type + typeof node.value + node.value;
-        } else if (node.type === "Identifier") {
-            return node.type + typeof node.name + node.name;
-        } else if (node.type === "MemberExpression") {
-            return node.type + getHash(node.object) + getHash(node.property);
-        } else if (node.type === "CallExpression") {
-            return node.type + getHash(node.callee) + node.arguments.map(getHash).join("");
-        } else if (node.type === "BinaryExpression") {
-            return node.type + getHash(node.left) + node.operator + getHash(node.right);
-        } else if (node.type === "ConditionalExpression") {
-            return node.type + getHash(node.test) + getHash(node.consequent) + getHash(node.alternate);
-        }
-    }
-
-    var switchStatement = [];
-
-    return {
-
-        "SwitchStatement": function(/*node*/) {
-            switchStatement.push({});
-        },
-
-        "SwitchStatement:exit": function(/*node*/) {
-            switchStatement.pop();
-        },
-
-        "SwitchCase": function(node) {
-            var currentSwitch = switchStatement[switchStatement.length - 1],
-                hashValue;
-
-            if (node.test) {
-                hashValue = getHash(node.test);
-                if (typeof hashValue !== "undefined" && currentSwitch.hasOwnProperty(hashValue)) {
-                    context.report(node, "Duplicate case label.");
-                } else {
-                    currentSwitch[hashValue] = true;
-                }
-            }
-        }
-
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to disallow a duplicate case label.
+ * @author Dieter Oberkofler
+ * @copyright 2015 Dieter Oberkofler. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Get a hash value for the node
+     * @param {ASTNode} node The node.
+     * @returns {string} A hash value for the node.
+     * @private
+     */
+    function getHash(node) {
+        if (node.type === "Literal") {
+            return node.type + typeof node.value + node.value;
+        } else if (node.type === "Identifier") {
+            return node.type + typeof node.name + node.name;
+        } else if (node.type === "MemberExpression") {
+            return node.type + getHash(node.object) + getHash(node.property);
+        } else if (node.type === "CallExpression") {
+            return node.type + getHash(node.callee) + node.arguments.map(getHash).join("");
+        } else if (node.type === "BinaryExpression") {
+            return node.type + getHash(node.left) + node.operator + getHash(node.right);
+        } else if (node.type === "ConditionalExpression") {
+            return node.type + getHash(node.test) + getHash(node.consequent) + getHash(node.alternate);
+        }
+    }
+
+    var switchStatement = [];
+
+    return {
+
+        "SwitchStatement": function(/*node*/) {
+            switchStatement.push({});
+        },
+
+        "SwitchStatement:exit": function(/*node*/) {
+            switchStatement.pop();
+        },
+
+        "SwitchCase": function(node) {
+            var currentSwitch = switchStatement[switchStatement.length - 1],
+                hashValue;
+
+            if (node.test) {
+                hashValue = getHash(node.test);
+                if (typeof hashValue !== "undefined" && currentSwitch.hasOwnProperty(hashValue)) {
+                    context.report(node, "Duplicate case label.");
+                } else {
+                    currentSwitch[hashValue] = true;
+                }
+            }
+        }
+
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-else-return.js

@@ -1,125 +1,125 @@
-/**
- * @fileoverview Rule to flag `else` after a `return` in `if`
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /**
-     * Display the context report if rule is violated
-     *
-     * @param {Node} node The 'else' node
-     * @returns {void}
-     */
-    function displayReport(node) {
-        context.report(node, "Unexpected 'else' after 'return'.");
-    }
-
-    /**
-     * Check to see if the node is a ReturnStatement
-     *
-     * @param {Node} node The node being evaluated
-     * @returns {boolean} True if node is a return
-     */
-    function checkForReturn(node) {
-        return node.type === "ReturnStatement";
-    }
-
-    /**
-     * Naive return checking, does not iterate through the whole
-     * BlockStatement because we make the assumption that the ReturnStatement
-     * will be the last node in the body of the BlockStatement.
-     *
-     * @param {Node} node The consequent/alternate node
-     * @returns {boolean} True if it has a return
-     */
-    function naiveHasReturn(node) {
-        if (node.type === "BlockStatement") {
-            var body = node.body,
-                lastChildNode = body[body.length - 1];
-
-            return lastChildNode && checkForReturn(lastChildNode);
-        }
-        return checkForReturn(node);
-    }
-
-    /**
-     * Check to see if the node is valid for evaluation,
-     * meaning it has an else and not an else-if
-     *
-     * @param {Node} node The node being evaluated
-     * @returns {boolean} True if the node is valid
-     */
-    function hasElse(node) {
-        return node.alternate && node.consequent && node.alternate.type !== "IfStatement";
-    }
-
-    /**
-     * If the consequent is an IfStatement, check to see if it has an else
-     * and both its consequent and alternate path return, meaning this is
-     * a nested case of rule violation.  If-Else not considered currently.
-     *
-     * @param {Node} node The consequent node
-     * @returns {boolean} True if this is a nested rule violation
-     */
-    function checkForIf(node) {
-        return node.type === "IfStatement" && hasElse(node) &&
-            naiveHasReturn(node.alternate) && naiveHasReturn(node.consequent);
-    }
-
-    /**
-     * Check the consequent/body node to make sure it is not
-     * a ReturnStatement or an IfStatement that returns on both
-     * code paths.  If it is, display the context report.
-     *
-     * @param {Node} node The consequent or body node
-     * @param {Node} alternate The alternate node
-     * @returns {void}
-     */
-    function checkForReturnOrIf(node, alternate) {
-        if (checkForReturn(node) || checkForIf(node)) {
-            displayReport(alternate);
-        }
-    }
-
-    //--------------------------------------------------------------------------
-    // Public API
-    //--------------------------------------------------------------------------
-
-    return {
-
-        "IfStatement": function (node) {
-            // Don't bother finding a ReturnStatement, if there's no `else`
-            // or if the alternate is also an if (indicating an else if).
-            if (hasElse(node)) {
-                var consequent = node.consequent,
-                    alternate = node.alternate;
-                // If we have a BlockStatement, check each consequent body node.
-                if (consequent.type === "BlockStatement") {
-                    var body = consequent.body;
-                    body.forEach(function (bodyNode) {
-                        checkForReturnOrIf(bodyNode, alternate);
-                    });
-                // If not a block statement, make sure the consequent isn't a ReturnStatement
-                // or an IfStatement with returns on both paths
-                } else {
-                    checkForReturnOrIf(consequent, alternate);
-                }
-            }
-        }
-
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag `else` after a `return` in `if`
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Display the context report if rule is violated
+     *
+     * @param {Node} node The 'else' node
+     * @returns {void}
+     */
+    function displayReport(node) {
+        context.report(node, "Unexpected 'else' after 'return'.");
+    }
+
+    /**
+     * Check to see if the node is a ReturnStatement
+     *
+     * @param {Node} node The node being evaluated
+     * @returns {boolean} True if node is a return
+     */
+    function checkForReturn(node) {
+        return node.type === "ReturnStatement";
+    }
+
+    /**
+     * Naive return checking, does not iterate through the whole
+     * BlockStatement because we make the assumption that the ReturnStatement
+     * will be the last node in the body of the BlockStatement.
+     *
+     * @param {Node} node The consequent/alternate node
+     * @returns {boolean} True if it has a return
+     */
+    function naiveHasReturn(node) {
+        if (node.type === "BlockStatement") {
+            var body = node.body,
+                lastChildNode = body[body.length - 1];
+
+            return lastChildNode && checkForReturn(lastChildNode);
+        }
+        return checkForReturn(node);
+    }
+
+    /**
+     * Check to see if the node is valid for evaluation,
+     * meaning it has an else and not an else-if
+     *
+     * @param {Node} node The node being evaluated
+     * @returns {boolean} True if the node is valid
+     */
+    function hasElse(node) {
+        return node.alternate && node.consequent && node.alternate.type !== "IfStatement";
+    }
+
+    /**
+     * If the consequent is an IfStatement, check to see if it has an else
+     * and both its consequent and alternate path return, meaning this is
+     * a nested case of rule violation.  If-Else not considered currently.
+     *
+     * @param {Node} node The consequent node
+     * @returns {boolean} True if this is a nested rule violation
+     */
+    function checkForIf(node) {
+        return node.type === "IfStatement" && hasElse(node) &&
+            naiveHasReturn(node.alternate) && naiveHasReturn(node.consequent);
+    }
+
+    /**
+     * Check the consequent/body node to make sure it is not
+     * a ReturnStatement or an IfStatement that returns on both
+     * code paths.  If it is, display the context report.
+     *
+     * @param {Node} node The consequent or body node
+     * @param {Node} alternate The alternate node
+     * @returns {void}
+     */
+    function checkForReturnOrIf(node, alternate) {
+        if (checkForReturn(node) || checkForIf(node)) {
+            displayReport(alternate);
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Public API
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "IfStatement": function (node) {
+            // Don't bother finding a ReturnStatement, if there's no `else`
+            // or if the alternate is also an if (indicating an else if).
+            if (hasElse(node)) {
+                var consequent = node.consequent,
+                    alternate = node.alternate;
+                // If we have a BlockStatement, check each consequent body node.
+                if (consequent.type === "BlockStatement") {
+                    var body = consequent.body;
+                    body.forEach(function (bodyNode) {
+                        checkForReturnOrIf(bodyNode, alternate);
+                    });
+                // If not a block statement, make sure the consequent isn't a ReturnStatement
+                // or an IfStatement with returns on both paths
+                } else {
+                    checkForReturnOrIf(consequent, alternate);
+                }
+            }
+        }
+
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-empty-character-class.js

@@ -1,43 +1,43 @@
-/**
- * @fileoverview Rule to flag the use of empty character classes in regular expressions
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/*
-plain-English description of the following regexp:
-0. `^` fix the match at the beginning of the string
-1. `\/`: the `/` that begins the regexp
-2. `([^\\[]|\\.|\[([^\\\]]|\\.)+\])*`: regexp contents; 0 or more of the following
-  2.0. `[^\\[]`: any character that's not a `\` or a `[` (anything but escape sequences and character classes)
-  2.1. `\\.`: an escape sequence
-  2.2. `\[([^\\\]]|\\.)+\]`: a character class that isn't empty
-3. `\/` the `/` that ends the regexp
-4. `[gimy]*`: optional regexp flags
-5. `$`: fix the match at the end of the string
-*/
-var regex = /^\/([^\\[]|\\.|\[([^\\\]]|\\.)+\])*\/[gimy]*$/;
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "Literal": function(node) {
-            var token = context.getFirstToken(node);
-            if (token.type === "RegularExpression" && !regex.test(token.value)) {
-                context.report(node, "Empty class.");
-            }
-        }
-
-    };
-
-};
+/**
+ * @fileoverview Rule to flag the use of empty character classes in regular expressions
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/*
+plain-English description of the following regexp:
+0. `^` fix the match at the beginning of the string
+1. `\/`: the `/` that begins the regexp
+2. `([^\\[]|\\.|\[([^\\\]]|\\.)+\])*`: regexp contents; 0 or more of the following
+  2.0. `[^\\[]`: any character that's not a `\` or a `[` (anything but escape sequences and character classes)
+  2.1. `\\.`: an escape sequence
+  2.2. `\[([^\\\]]|\\.)+\]`: a character class that isn't empty
+3. `\/` the `/` that ends the regexp
+4. `[gimuy]*`: optional regexp flags
+5. `$`: fix the match at the end of the string
+*/
+var regex = /^\/([^\\[]|\\.|\[([^\\\]]|\\.)+\])*\/[gimuy]*$/;
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "Literal": function(node) {
+            var token = context.getFirstToken(node);
+            if (token.type === "RegularExpression" && !regex.test(token.value)) {
+                context.report(node, "Empty class.");
+            }
+        }
+
+    };
+
+};

package/lib/rules/no-empty-class.js

@@ -1,45 +1,45 @@
-/**
- * @fileoverview Rule to flag the use of empty character classes in regular expressions
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/*
-plain-English description of the following regexp:
-0. `^` fix the match at the beginning of the string
-1. `\/`: the `/` that begins the regexp
-2. `([^\\[]|\\.|\[([^\\\]]|\\.)+\])*`: regexp contents; 0 or more of the following
-  2.0. `[^\\[]`: any character that's not a `\` or a `[` (anything but escape sequences and character classes)
-  2.1. `\\.`: an escape sequence
-  2.2. `\[([^\\\]]|\\.)+\]`: a character class that isn't empty
-3. `\/` the `/` that ends the regexp
-4. `[gimy]*`: optional regexp flags
-5. `$`: fix the match at the end of the string
-*/
-var regex = /^\/([^\\[]|\\.|\[([^\\\]]|\\.)+\])*\/[gimy]*$/;
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "Literal": function(node) {
-            var token = context.getFirstToken(node);
-            if (token.type === "RegularExpression" && !regex.test(token.value)) {
-                context.report(node, "Empty class.");
-            }
-        }
-
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag the use of empty character classes in regular expressions
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/*
+plain-English description of the following regexp:
+0. `^` fix the match at the beginning of the string
+1. `\/`: the `/` that begins the regexp
+2. `([^\\[]|\\.|\[([^\\\]]|\\.)+\])*`: regexp contents; 0 or more of the following
+  2.0. `[^\\[]`: any character that's not a `\` or a `[` (anything but escape sequences and character classes)
+  2.1. `\\.`: an escape sequence
+  2.2. `\[([^\\\]]|\\.)+\]`: a character class that isn't empty
+3. `\/` the `/` that ends the regexp
+4. `[gimy]*`: optional regexp flags
+5. `$`: fix the match at the end of the string
+*/
+var regex = /^\/([^\\[]|\\.|\[([^\\\]]|\\.)+\])*\/[gimy]*$/;
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "Literal": function(node) {
+            var token = context.getFirstToken(node);
+            if (token.type === "RegularExpression" && !regex.test(token.value)) {
+                context.report(node, "Empty class.");
+            }
+        }
+
+    };
+
+};
+
+module.exports.schema = [];