eslint 0.22.0 → 0.24.1

package/lib/rules/prefer-const.js

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview A rule to suggest using of const declaration for variables that are never modified after declared.
+ * @author Toru Nagashima
+ * @copyright 2015 Toru Nagashima. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Checks whether a reference is the initializer.
+     * @param {Reference} reference - A reference to check.
+     * @returns {boolean} Whether or not the reference is the initializer.
+     */
+    function isInitializer(reference) {
+        return reference.init === true;
+    }
+
+    /**
+     * Checks whether a reference is read-only or the initializer.
+     * @param {Reference} reference - A reference to check.
+     * @returns {boolean} Whether or not the reference is read-only or the initializer.
+     */
+    function isReadOnlyOrInitializer(reference) {
+        return reference.isReadOnly() || reference.init === true;
+    }
+
+    /**
+     * Searches and reports variables that are never modified after declared.
+     * @param {Scope} scope - A scope of the search domain.
+     * @returns {void}
+     */
+    function checkForVariables(scope) {
+        // Skip the TDZ type.
+        if (scope.type === "TDZ") {
+            return;
+        }
+
+        var variables = scope.variables;
+        for (var i = 0, end = variables.length; i < end; ++i) {
+            var variable = variables[i];
+            var def = variable.defs[0];
+            var declaration = def && def.parent;
+            var statement = declaration && declaration.parent;
+            var references = variable.references;
+            var identifier = variable.identifiers[0];
+
+            if (statement != null &&
+                identifier != null &&
+                declaration.type === "VariableDeclaration" &&
+                declaration.kind === "let" &&
+                (statement.type !== "ForStatement" || statement.init !== declaration) &&
+                references.some(isInitializer) &&
+                references.every(isReadOnlyOrInitializer)
+            ) {
+                context.report(
+                    identifier,
+                    "`{{name}}` is never modified, use `const` instead.",
+                    {name: identifier.name});
+            }
+        }
+    }
+
+    /**
+     * Adds multiple items to the tail of an array.
+     * @param {any[]} array - A destination to add.
+     * @param {any[]} values - Items to be added.
+     * @returns {void}
+     */
+    var pushAll = Function.apply.bind(Array.prototype.push);
+
+    return {
+        "Program:exit": function () {
+            var stack = [context.getScope()];
+            while (stack.length) {
+                var scope = stack.pop();
+                pushAll(stack, scope.childScopes);
+
+                checkForVariables(scope);
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/quote-props.js

@@ -1,72 +1,72 @@
-/**
- * @fileoverview Rule to flag non-quoted property names in object literals.
- * @author Mathias Bynens <http://mathiasbynens.be/>
- * @copyright 2014 Brandon Mills. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-var espree = require("espree");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var MODE = context.options[0];
-
-    /**
-     * Ensures that a property's key is quoted only when necessary
-     * @param   {ASTNode} node Property AST node
-     * @returns {void}
-     */
-    function asNeeded(node) {
-        var key = node.key,
-            tokens;
-
-        if (key.type === "Literal" && typeof key.value === "string") {
-            try {
-                tokens = espree.tokenize(key.value);
-            } catch (e) {
-                return;
-            }
-
-            if (tokens.length === 1 &&
-                (["Identifier", "Null", "Boolean"].indexOf(tokens[0].type) >= 0 ||
-                (tokens[0].type === "Numeric" && "" + +tokens[0].value === tokens[0].value))
-            ) {
-                context.report(node, "Unnecessarily quoted property `{{value}}` found.", key);
-            }
-        }
-    }
-
-    /**
-     * Ensures that a property's key is quoted
-     * @param   {ASTNode} node Property AST node
-     * @returns {void}
-     */
-    function always(node) {
-        var key = node.key;
-
-        if (!node.method && !(key.type === "Literal" && typeof key.value === "string")) {
-            context.report(node, "Unquoted property `{{key}}` found.", {
-                key: key.name || key.value
-            });
-        }
-    }
-
-    return {
-        "Property": MODE === "as-needed" ? asNeeded : always
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["always", "as-needed"]
-    }
-];
+/**
+ * @fileoverview Rule to flag non-quoted property names in object literals.
+ * @author Mathias Bynens <http://mathiasbynens.be/>
+ * @copyright 2014 Brandon Mills. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var espree = require("espree");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var MODE = context.options[0];
+
+    /**
+     * Ensures that a property's key is quoted only when necessary
+     * @param   {ASTNode} node Property AST node
+     * @returns {void}
+     */
+    function asNeeded(node) {
+        var key = node.key,
+            tokens;
+
+        if (key.type === "Literal" && typeof key.value === "string") {
+            try {
+                tokens = espree.tokenize(key.value);
+            } catch (e) {
+                return;
+            }
+
+            if (tokens.length === 1 &&
+                (["Identifier", "Null", "Boolean"].indexOf(tokens[0].type) >= 0 ||
+                (tokens[0].type === "Numeric" && "" + +tokens[0].value === tokens[0].value))
+            ) {
+                context.report(node, "Unnecessarily quoted property `{{value}}` found.", key);
+            }
+        }
+    }
+
+    /**
+     * Ensures that a property's key is quoted
+     * @param   {ASTNode} node Property AST node
+     * @returns {void}
+     */
+    function always(node) {
+        var key = node.key;
+
+        if (!node.method && !(key.type === "Literal" && typeof key.value === "string")) {
+            context.report(node, "Unquoted property `{{key}}` found.", {
+                key: key.name || key.value
+            });
+        }
+    }
+
+    return {
+        "Property": MODE === "as-needed" ? asNeeded : always
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["always", "as-needed"]
+    }
+];

package/lib/rules/quotes.js

@@ -1,92 +1,92 @@
-/**
- * @fileoverview A rule to choose between single and double quote marks
- * @author Matt DuVall <http://www.mattduvall.com/>, Brandon Payton
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Constants
-//------------------------------------------------------------------------------
-
-var QUOTE_SETTINGS = {
-    "double": {
-        quote: "\"",
-        alternateQuote: "'",
-        description: "doublequote"
-    },
-    "single": {
-        quote: "'",
-        alternateQuote: "\"",
-        description: "singlequote"
-    },
-    "backtick": {
-        quote: "`",
-        alternateQuote: "\"",
-        description: "backtick"
-    }
-};
-
-var AVOID_ESCAPE = "avoid-escape";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * Validate that a string passed in is surrounded by the specified character
-     * @param  {string} val The text to check.
-     * @param  {string} character The character to see if it's surrounded by.
-     * @returns {boolean} True if the text is surrounded by the character, false if not.
-     * @private
-     */
-    function isSurroundedBy(val, character) {
-        return val[0] === character && val[val.length - 1] === character;
-    }
-
-    /**
-     * Determines if a given node is part of JSX syntax.
-     * @param {ASTNode} node The node to check.
-     * @returns {boolean} True if the node is a JSX node, false if not.
-     * @private
-     */
-    function isJSXElement(node) {
-        return node.type.indexOf("JSX") === 0;
-    }
-
-    return {
-
-        "Literal": function(node) {
-            var val = node.value,
-                rawVal = node.raw,
-                quoteOption = context.options[0],
-                settings = QUOTE_SETTINGS[quoteOption || "double"],
-                avoidEscape = context.options[1] === AVOID_ESCAPE,
-                isValid;
-
-            if (settings && typeof val === "string") {
-                isValid = isJSXElement(node.parent) || isSurroundedBy(rawVal, settings.quote);
-
-                if (!isValid && avoidEscape) {
-                    isValid = isSurroundedBy(rawVal, settings.alternateQuote) && rawVal.indexOf(settings.quote) >= 0;
-                }
-
-                if (!isValid) {
-                    context.report(node, "Strings must use " + settings.description + ".");
-                }
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["single", "double", "backtick"]
-    },
-    {
-        "enum": ["avoid-escape"]
-    }
-];
+/**
+ * @fileoverview A rule to choose between single and double quote marks
+ * @author Matt DuVall <http://www.mattduvall.com/>, Brandon Payton
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Constants
+//------------------------------------------------------------------------------
+
+var QUOTE_SETTINGS = {
+    "double": {
+        quote: "\"",
+        alternateQuote: "'",
+        description: "doublequote"
+    },
+    "single": {
+        quote: "'",
+        alternateQuote: "\"",
+        description: "singlequote"
+    },
+    "backtick": {
+        quote: "`",
+        alternateQuote: "\"",
+        description: "backtick"
+    }
+};
+
+var AVOID_ESCAPE = "avoid-escape";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Validate that a string passed in is surrounded by the specified character
+     * @param  {string} val The text to check.
+     * @param  {string} character The character to see if it's surrounded by.
+     * @returns {boolean} True if the text is surrounded by the character, false if not.
+     * @private
+     */
+    function isSurroundedBy(val, character) {
+        return val[0] === character && val[val.length - 1] === character;
+    }
+
+    /**
+     * Determines if a given node is part of JSX syntax.
+     * @param {ASTNode} node The node to check.
+     * @returns {boolean} True if the node is a JSX node, false if not.
+     * @private
+     */
+    function isJSXElement(node) {
+        return node.type.indexOf("JSX") === 0;
+    }
+
+    return {
+
+        "Literal": function(node) {
+            var val = node.value,
+                rawVal = node.raw,
+                quoteOption = context.options[0],
+                settings = QUOTE_SETTINGS[quoteOption || "double"],
+                avoidEscape = context.options[1] === AVOID_ESCAPE,
+                isValid;
+
+            if (settings && typeof val === "string") {
+                isValid = isJSXElement(node.parent) || isSurroundedBy(rawVal, settings.quote);
+
+                if (!isValid && avoidEscape) {
+                    isValid = isSurroundedBy(rawVal, settings.alternateQuote) && rawVal.indexOf(settings.quote) >= 0;
+                }
+
+                if (!isValid) {
+                    context.report(node, "Strings must use " + settings.description + ".");
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["single", "double", "backtick"]
+    },
+    {
+        "enum": ["avoid-escape"]
+    }
+];

package/lib/rules/radix.js

@@ -1,41 +1,41 @@
-/**
- * @fileoverview Rule to flag use of parseInt without a radix argument
- * @author James Allardice
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-        "CallExpression": function(node) {
-
-            var radix;
-
-            if (node.callee.name === "parseInt") {
-
-                if (node.arguments.length < 2) {
-                    context.report(node, "Missing radix parameter.");
-                } else {
-
-                    radix = node.arguments[1];
-
-                    // don't allow non-numeric literals or undefined
-                    if ((radix.type === "Literal" && typeof radix.value !== "number") ||
-                        (radix.type === "Identifier" && radix.name === "undefined")
-                    ) {
-                        context.report(node, "Invalid radix parameter.");
-                    }
-                }
-
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of parseInt without a radix argument
+ * @author James Allardice
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+        "CallExpression": function(node) {
+
+            var radix;
+
+            if (node.callee.name === "parseInt") {
+
+                if (node.arguments.length < 2) {
+                    context.report(node, "Missing radix parameter.");
+                } else {
+
+                    radix = node.arguments[1];
+
+                    // don't allow non-numeric literals or undefined
+                    if ((radix.type === "Literal" && typeof radix.value !== "number") ||
+                        (radix.type === "Identifier" && radix.name === "undefined")
+                    ) {
+                        context.report(node, "Invalid radix parameter.");
+                    }
+                }
+
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];