eslint 0.22.0 → 0.24.1

package/lib/rules/no-redeclare.js

@@ -1,68 +1,68 @@
-/**
- * @fileoverview Rule to flag when the same variable is declared more then once.
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * Find variables in a given scope and flag redeclared ones.
-     * @param {Scope} scope An escope scope object.
-     * @returns {void}
-     * @private
-     */
-    function findVariablesInScope(scope) {
-        scope.variables.forEach(function(variable) {
-            if (variable.identifiers && variable.identifiers.length > 1) {
-                variable.identifiers.sort(function(a, b) {
-                    return a.range[1] - b.range[1];
-                });
-
-                for (var i = 1, l = variable.identifiers.length; i < l; i++) {
-                    context.report(variable.identifiers[i], "{{a}} is already defined", {a: variable.name});
-                }
-            }
-        });
-
-    }
-
-    /**
-     * Find variables in a given node's associated scope.
-     * @param {ASTNode} node The node to check.
-     * @returns {void}
-     * @private
-     */
-    function findVariables(node) {
-        var scope = context.getScope();
-
-        findVariablesInScope(scope);
-
-        // globalReturn means one extra scope to check
-        if (node.type === "Program" && context.ecmaFeatures.globalReturn) {
-            findVariablesInScope(scope.childScopes[0]);
-        }
-    }
-
-    if (context.ecmaFeatures.blockBindings) {
-        return {
-            "Program": findVariables,
-            "BlockStatement": findVariables,
-            "SwitchStatement": findVariables
-        };
-    } else {
-        return {
-            "Program": findVariables,
-            "FunctionDeclaration": findVariables,
-            "FunctionExpression": findVariables,
-            "ArrowFunctionExpression": findVariables
-        };
-    }
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag when the same variable is declared more then once.
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Find variables in a given scope and flag redeclared ones.
+     * @param {Scope} scope An escope scope object.
+     * @returns {void}
+     * @private
+     */
+    function findVariablesInScope(scope) {
+        scope.variables.forEach(function(variable) {
+            if (variable.identifiers && variable.identifiers.length > 1) {
+                variable.identifiers.sort(function(a, b) {
+                    return a.range[1] - b.range[1];
+                });
+
+                for (var i = 1, l = variable.identifiers.length; i < l; i++) {
+                    context.report(variable.identifiers[i], "{{a}} is already defined", {a: variable.name});
+                }
+            }
+        });
+
+    }
+
+    /**
+     * Find variables in a given node's associated scope.
+     * @param {ASTNode} node The node to check.
+     * @returns {void}
+     * @private
+     */
+    function findVariables(node) {
+        var scope = context.getScope();
+
+        findVariablesInScope(scope);
+
+        // globalReturn means one extra scope to check
+        if (node.type === "Program" && (context.ecmaFeatures.globalReturn || context.ecmaFeatures.modules)) {
+            findVariablesInScope(scope.childScopes[0]);
+        }
+    }
+
+    if (context.ecmaFeatures.blockBindings) {
+        return {
+            "Program": findVariables,
+            "BlockStatement": findVariables,
+            "SwitchStatement": findVariables
+        };
+    } else {
+        return {
+            "Program": findVariables,
+            "FunctionDeclaration": findVariables,
+            "FunctionExpression": findVariables,
+            "ArrowFunctionExpression": findVariables
+        };
+    }
+};
+
+module.exports.schema = [];

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

@@ -1,35 +1,35 @@
-/**
- * @fileoverview Rule to count multiple spaces in regular expressions
- * @author Matt DuVall <http://www.mattduvall.com/>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "Literal": function(node) {
-            var token = context.getFirstToken(node),
-                nodeType = token.type,
-                nodeValue = token.value,
-                multipleSpacesRegex = /( {2,})+?/,
-                regexResults;
-
-            if (nodeType === "RegularExpression") {
-                regexResults = multipleSpacesRegex.exec(nodeValue);
-
-                if (regexResults !== null) {
-                    context.report(node, "Spaces are hard to count. Use {" + regexResults[0].length + "}.");
-                }
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to count multiple spaces in regular expressions
+ * @author Matt DuVall <http://www.mattduvall.com/>
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "Literal": function(node) {
+            var token = context.getFirstToken(node),
+                nodeType = token.type,
+                nodeValue = token.value,
+                multipleSpacesRegex = /( {2,})+?/,
+                regexResults;
+
+            if (nodeType === "RegularExpression") {
+                regexResults = multipleSpacesRegex.exec(nodeValue);
+
+                if (regexResults !== null) {
+                    context.report(node, "Spaces are hard to count. Use {" + regexResults[0].length + "}.");
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

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

@@ -1,56 +1,56 @@
-/**
- * @fileoverview Rule to disallow reserved words being used as keys
- * @author Emil Bay
- * @copyright 2014 Emil Bay. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var MESSAGE = "Reserved word '{{key}}' used as key.";
-
-    var reservedWords = [
-        "abstract",
-        "boolean", "break", "byte",
-        "case", "catch", "char", "class", "const", "continue",
-        "debugger", "default", "delete", "do", "double",
-        "else", "enum", "export", "extends",
-        "final", "finally", "float", "for", "function",
-        "goto",
-        "if", "implements", "import", "in", "instanceof", "int", "interface",
-        "long",
-        "native", "new",
-        "package", "private", "protected", "public",
-        "return",
-        "short", "static", "super", "switch", "synchronized",
-        "this", "throw", "throws", "transient", "try", "typeof",
-        "var", "void", "volatile",
-        "while", "with"
-    ];
-
-    return {
-
-        "ObjectExpression": function(node) {
-            node.properties.forEach(function(property) {
-
-                if (property.key.type === "Identifier") {
-                    var keyName = property.key.name;
-
-                    if (reservedWords.indexOf("" + keyName) !== -1) {
-                        context.report(node, MESSAGE, { key: keyName });
-                    }
-                }
-
-            });
-
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to disallow reserved words being used as keys
+ * @author Emil Bay
+ * @copyright 2014 Emil Bay. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var MESSAGE = "Reserved word '{{key}}' used as key.";
+
+    var reservedWords = [
+        "abstract",
+        "boolean", "break", "byte",
+        "case", "catch", "char", "class", "const", "continue",
+        "debugger", "default", "delete", "do", "double",
+        "else", "enum", "export", "extends",
+        "final", "finally", "float", "for", "function",
+        "goto",
+        "if", "implements", "import", "in", "instanceof", "int", "interface",
+        "long",
+        "native", "new",
+        "package", "private", "protected", "public",
+        "return",
+        "short", "static", "super", "switch", "synchronized",
+        "this", "throw", "throws", "transient", "try", "typeof",
+        "var", "void", "volatile",
+        "while", "with"
+    ];
+
+    return {
+
+        "ObjectExpression": function(node) {
+            node.properties.forEach(function(property) {
+
+                if (property.key.type === "Identifier") {
+                    var keyName = property.key.name;
+
+                    if (reservedWords.indexOf("" + keyName) !== -1) {
+                        context.report(node, MESSAGE, { key: keyName });
+                    }
+                }
+
+            });
+
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-restricted-modules.js

@@ -1,85 +1,85 @@
-/**
- * @fileoverview Restrict usage of specified node modules.
- * @author Christian Schulz
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function (context) {
-    // trim restricted module names
-    var restrictedModules = context.options;
-
-    // if no modules are restricted we don't need to check the CallExpressions
-    if (restrictedModules.length === 0) {
-        return {};
-    }
-
-    /**
-     * Function to check if a node is a string literal.
-     * @param {ASTNode} node The node to check.
-     * @returns {boolean} If the node is a string literal.
-     */
-    function isString(node) {
-        return node && node.type === "Literal" && typeof node.value === "string";
-    }
-
-    /**
-     * Function to check if a node is a require call.
-     * @param {ASTNode} node The node to check.
-     * @returns {boolean} If the node is a require call.
-     */
-    function isRequireCall(node) {
-        return node.callee.type === "Identifier" && node.callee.name === "require";
-    }
-
-    /**
-     * Function to check if a node has an argument that is an restricted module and return its name.
-     * @param {ASTNode} node The node to check
-     * @returns {undefined|String} restricted module name or undefined if node argument isn't restricted.
-     */
-    function getRestrictedModuleName(node) {
-        var moduleName;
-
-        // node has arguments and first argument is string
-        if (node.arguments.length && isString(node.arguments[0])) {
-            var argumentValue = node.arguments[0].value.trim();
-
-            // check if argument value is in restricted modules array
-            if (restrictedModules.indexOf(argumentValue) !== -1) {
-                moduleName = argumentValue;
-            }
-        }
-
-        return moduleName;
-    }
-
-    return {
-        "CallExpression": function (node) {
-            if (isRequireCall(node)) {
-                var restrictedModuleName = getRestrictedModuleName(node);
-
-                if (restrictedModuleName) {
-                    context.report(node, "'{{moduleName}}' module is restricted from being used.", {
-                        moduleName: restrictedModuleName
-                    });
-                }
-            }
-        }
-    };
-};
-
-module.exports.schema = {
-    "type": "array",
-    "items": [
-        {
-            "enum": [0, 1, 2]
-        }
-    ],
-    "additionalItems": {
-        "type": "string"
-    },
-    "uniqueItems": true
-};
+/**
+ * @fileoverview Restrict usage of specified node modules.
+ * @author Christian Schulz
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function (context) {
+    // trim restricted module names
+    var restrictedModules = context.options;
+
+    // if no modules are restricted we don't need to check the CallExpressions
+    if (restrictedModules.length === 0) {
+        return {};
+    }
+
+    /**
+     * Function to check if a node is a string literal.
+     * @param {ASTNode} node The node to check.
+     * @returns {boolean} If the node is a string literal.
+     */
+    function isString(node) {
+        return node && node.type === "Literal" && typeof node.value === "string";
+    }
+
+    /**
+     * Function to check if a node is a require call.
+     * @param {ASTNode} node The node to check.
+     * @returns {boolean} If the node is a require call.
+     */
+    function isRequireCall(node) {
+        return node.callee.type === "Identifier" && node.callee.name === "require";
+    }
+
+    /**
+     * Function to check if a node has an argument that is an restricted module and return its name.
+     * @param {ASTNode} node The node to check
+     * @returns {undefined|String} restricted module name or undefined if node argument isn't restricted.
+     */
+    function getRestrictedModuleName(node) {
+        var moduleName;
+
+        // node has arguments and first argument is string
+        if (node.arguments.length && isString(node.arguments[0])) {
+            var argumentValue = node.arguments[0].value.trim();
+
+            // check if argument value is in restricted modules array
+            if (restrictedModules.indexOf(argumentValue) !== -1) {
+                moduleName = argumentValue;
+            }
+        }
+
+        return moduleName;
+    }
+
+    return {
+        "CallExpression": function (node) {
+            if (isRequireCall(node)) {
+                var restrictedModuleName = getRestrictedModuleName(node);
+
+                if (restrictedModuleName) {
+                    context.report(node, "'{{moduleName}}' module is restricted from being used.", {
+                        moduleName: restrictedModuleName
+                    });
+                }
+            }
+        }
+    };
+};
+
+module.exports.schema = {
+    "type": "array",
+    "items": [
+        {
+            "enum": [0, 1, 2]
+        }
+    ],
+    "additionalItems": {
+        "type": "string"
+    },
+    "uniqueItems": true
+};

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

@@ -1,24 +1,53 @@
-/**
- * @fileoverview Rule to flag when return statement contains assignment
- * @author Ilya Volodin
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "ReturnStatement": function(node) {
-            if (node.argument && node.argument.type === "AssignmentExpression") {
-                context.report(node, "Return statement should not contain assignment.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag when return statement contains assignment
+ * @author Ilya Volodin
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether or not a node is an `AssignmentExpression`.
+ * @param {Node|null} node - A node to check.
+ * @returns {boolean} Whether or not the node is an `AssignmentExpression`.
+ */
+function isAssignment(node) {
+    return node != null && node.type === "AssignmentExpression";
+}
+
+/**
+ * Checks whether or not a node is enclosed in parentheses.
+ * @param {Node|null} node - A node to check.
+ * @param {RuleContext} context - The current context.
+ * @returns {boolean} Whether or not the node is enclosed in parentheses.
+ */
+function isEnclosedInParens(node, context) {
+    var prevToken = context.getTokenBefore(node);
+    var nextToken = context.getTokenAfter(node);
+
+    return prevToken.value === "(" && nextToken.value === ")";
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+    var always = (context.options[0] || "except-parens") !== "except-parens";
+
+    return {
+        "ReturnStatement": function(node) {
+            if (isAssignment(node.argument) && (always || !isEnclosedInParens(node.argument, context))) {
+                context.report(node, "Return statement should not contain assignment.");
+            }
+        }
+    };
+};
+
+module.exports.schema = [
+    {
+        "enum": ["except-parens", "always"]
+    }
+];

package/lib/rules/no-script-url.js

@@ -1,34 +1,34 @@
-/**
- * @fileoverview Rule to flag when using javascript: urls
- * @author Ilya Volodin
- */
-/*jshint scripturl: true */
-/*eslint no-script-url: 0*/
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "Literal": function(node) {
-
-            var value;
-
-            if (node.value && typeof node.value === "string") {
-                value = node.value.toLowerCase();
-
-                if (value.indexOf("javascript:") === 0) {
-                    context.report(node, "Script URL is a form of eval.");
-                }
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag when using javascript: urls
+ * @author Ilya Volodin
+ */
+/*jshint scripturl: true */
+/*eslint no-script-url: 0*/
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "Literal": function(node) {
+
+            var value;
+
+            if (node.value && typeof node.value === "string") {
+                value = node.value.toLowerCase();
+
+                if (value.indexOf("javascript:") === 0) {
+                    context.report(node, "Script URL is a form of eval.");
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];