eslint 0.22.0 → 0.24.1

package/lib/rules/dot-notation.js

@@ -1,119 +1,119 @@
-/**
- * @fileoverview Rule to warn about using dot notation instead of square bracket notation when possible.
- * @author Josh Perez
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-var validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-var keywords = [
-    "this",
-    "function",
-    "if",
-    "return",
-    "var",
-    "else",
-    "for",
-    "new",
-    "in",
-    "typeof",
-    "while",
-    "case",
-    "break",
-    "try",
-    "catch",
-    "delete",
-    "throw",
-    "switch",
-    "continue",
-    "default",
-    "instanceof",
-    "do",
-    "void",
-    "finally",
-    "with",
-    "debugger",
-    "implements",
-    "interface",
-    "package",
-    "private",
-    "protected",
-    "public",
-    "static",
-    "class",
-    "enum",
-    "export",
-    "extends",
-    "import",
-    "super",
-    "true",
-    "false",
-    "null",
-    "abstract",
-    "boolean",
-    "byte",
-    "char",
-    "const",
-    "double",
-    "final",
-    "float",
-    "goto",
-    "int",
-    "long",
-    "native",
-    "short",
-    "synchronized",
-    "throws",
-    "transient",
-    "volatile"
-];
-
-module.exports = function(context) {
-    var options = context.options[0] || {};
-    var allowKeywords = options.allowKeywords === void 0 || !!options.allowKeywords;
-
-    var allowPattern;
-    if (options.allowPattern) {
-        allowPattern = new RegExp(options.allowPattern);
-    }
-
-    return {
-        "MemberExpression": function(node) {
-            if (
-                node.computed &&
-                node.property.type === "Literal" &&
-                validIdentifier.test(node.property.value) &&
-                (allowKeywords || keywords.indexOf("" + node.property.value) === -1)
-            ) {
-                if (!(allowPattern && allowPattern.test(node.property.value))) {
-                    context.report(node, "[" + JSON.stringify(node.property.value) + "] is better written in dot notation.");
-                }
-            }
-            if (
-                !allowKeywords &&
-                !node.computed &&
-                keywords.indexOf("" + node.property.name) !== -1
-            ) {
-                context.report(node, "." + node.property.name + " is a syntax error.");
-            }
-        }
-    };
-};
-
-module.exports.schema = [
-    {
-        "type": "object",
-        "properties": {
-            "allowKeywords": {
-                "type": "boolean"
-            },
-            "allowPattern": {
-                "type": "string"
-            }
-        },
-        "additionalProperties": false
-    }
-];
+/**
+ * @fileoverview Rule to warn about using dot notation instead of square bracket notation when possible.
+ * @author Josh Perez
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+var validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+var keywords = [
+    "this",
+    "function",
+    "if",
+    "return",
+    "var",
+    "else",
+    "for",
+    "new",
+    "in",
+    "typeof",
+    "while",
+    "case",
+    "break",
+    "try",
+    "catch",
+    "delete",
+    "throw",
+    "switch",
+    "continue",
+    "default",
+    "instanceof",
+    "do",
+    "void",
+    "finally",
+    "with",
+    "debugger",
+    "implements",
+    "interface",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "static",
+    "class",
+    "enum",
+    "export",
+    "extends",
+    "import",
+    "super",
+    "true",
+    "false",
+    "null",
+    "abstract",
+    "boolean",
+    "byte",
+    "char",
+    "const",
+    "double",
+    "final",
+    "float",
+    "goto",
+    "int",
+    "long",
+    "native",
+    "short",
+    "synchronized",
+    "throws",
+    "transient",
+    "volatile"
+];
+
+module.exports = function(context) {
+    var options = context.options[0] || {};
+    var allowKeywords = options.allowKeywords === void 0 || !!options.allowKeywords;
+
+    var allowPattern;
+    if (options.allowPattern) {
+        allowPattern = new RegExp(options.allowPattern);
+    }
+
+    return {
+        "MemberExpression": function(node) {
+            if (
+                node.computed &&
+                node.property.type === "Literal" &&
+                validIdentifier.test(node.property.value) &&
+                (allowKeywords || keywords.indexOf("" + node.property.value) === -1)
+            ) {
+                if (!(allowPattern && allowPattern.test(node.property.value))) {
+                    context.report(node, "[" + JSON.stringify(node.property.value) + "] is better written in dot notation.");
+                }
+            }
+            if (
+                !allowKeywords &&
+                !node.computed &&
+                keywords.indexOf("" + node.property.name) !== -1
+            ) {
+                context.report(node, "." + node.property.name + " is a syntax error.");
+            }
+        }
+    };
+};
+
+module.exports.schema = [
+    {
+        "type": "object",
+        "properties": {
+            "allowKeywords": {
+                "type": "boolean"
+            },
+            "allowPattern": {
+                "type": "string"
+            }
+        },
+        "additionalProperties": false
+    }
+];

package/lib/rules/eol-last.js

@@ -1,38 +1,38 @@
-/**
- * @fileoverview Require file to end with single newline.
- * @author Nodeca Team <https://github.com/nodeca>
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    return {
-
-        "Program": function checkBadEOF(node) {
-            // Get the whole source code, not for node only.
-            var src = context.getSource(), location = {column: 1};
-
-            if (src.length === 0) {
-                return;
-            }
-
-            if (src[src.length - 1] !== "\n") {
-                // file is not newline-terminated
-                location.line = src.split(/\n/g).length;
-                context.report(node, location, "Newline required at end of file but not found.");
-            }
-        }
-
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Require file to end with single newline.
+ * @author Nodeca Team <https://github.com/nodeca>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "Program": function checkBadEOF(node) {
+            // Get the whole source code, not for node only.
+            var src = context.getSource(), location = {column: 1};
+
+            if (src.length === 0) {
+                return;
+            }
+
+            if (src[src.length - 1] !== "\n") {
+                // file is not newline-terminated
+                location.line = src.split(/\n/g).length;
+                context.report(node, location, "Newline required at end of file but not found.");
+            }
+        }
+
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/eqeqeq.js

@@ -1,96 +1,96 @@
-/**
- * @fileoverview Rule to flag statements that use != and == instead of !== and ===
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * Checks if an expression is a typeof expression
-     * @param  {ASTNode} node The node to check
-     * @returns {boolean} if the node is a typeof expression
-     */
-    function isTypeOf(node) {
-        return node.type === "UnaryExpression" && node.operator === "typeof";
-    }
-
-    /**
-     * Checks if either operand of a binary expression is a typeof operation
-     * @param {ASTNode} node The node to check
-     * @returns {boolean} if one of the operands is typeof
-     * @private
-     */
-    function isTypeOfBinary(node) {
-        return isTypeOf(node.left) || isTypeOf(node.right);
-    }
-
-    /**
-     * Checks if operands are literals of the same type (via typeof)
-     * @param {ASTNode} node The node to check
-     * @returns {boolean} if operands are of same type
-     * @private
-     */
-    function areLiteralsAndSameType(node) {
-        return node.left.type === "Literal" && node.right.type === "Literal" &&
-                typeof node.left.value === typeof node.right.value;
-    }
-
-    /**
-     * Checks if one of the operands is a literal null
-     * @param {ASTNode} node The node to check
-     * @returns {boolean} if operands are null
-     * @private
-     */
-    function isNullCheck(node) {
-        return (node.right.type === "Literal" && node.right.value === null) ||
-                (node.left.type === "Literal" && node.left.value === null);
-    }
-
-    /**
-     * Gets the location (line and column) of the binary expression's operator
-     * @param {ASTNode} node The binary expression node to check
-     * @param {String} operator The operator to find
-     * @returns {Object} { line, column } location of operator
-     * @private
-     */
-    function getOperatorLocation(node) {
-        var opToken = context.getTokenAfter(node.left);
-        return {line: opToken.loc.start.line, column: opToken.loc.start.column};
-    }
-
-    return {
-        "BinaryExpression": function(node) {
-            if (node.operator !== "==" && node.operator !== "!=") {
-                return;
-            }
-
-            if (context.options[0] === "smart" && (isTypeOfBinary(node) ||
-                    areLiteralsAndSameType(node)) || isNullCheck(node)) {
-                return;
-            }
-
-            if (context.options[0] === "allow-null" && isNullCheck(node)) {
-                return;
-            }
-
-            context.report(
-                node, getOperatorLocation(node),
-                "Expected '{{op}}=' and instead saw '{{op}}'.",
-                {op: node.operator}
-            );
-        }
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["smart", "allow-null"]
-    }
-];
+/**
+ * @fileoverview Rule to flag statements that use != and == instead of !== and ===
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Checks if an expression is a typeof expression
+     * @param  {ASTNode} node The node to check
+     * @returns {boolean} if the node is a typeof expression
+     */
+    function isTypeOf(node) {
+        return node.type === "UnaryExpression" && node.operator === "typeof";
+    }
+
+    /**
+     * Checks if either operand of a binary expression is a typeof operation
+     * @param {ASTNode} node The node to check
+     * @returns {boolean} if one of the operands is typeof
+     * @private
+     */
+    function isTypeOfBinary(node) {
+        return isTypeOf(node.left) || isTypeOf(node.right);
+    }
+
+    /**
+     * Checks if operands are literals of the same type (via typeof)
+     * @param {ASTNode} node The node to check
+     * @returns {boolean} if operands are of same type
+     * @private
+     */
+    function areLiteralsAndSameType(node) {
+        return node.left.type === "Literal" && node.right.type === "Literal" &&
+                typeof node.left.value === typeof node.right.value;
+    }
+
+    /**
+     * Checks if one of the operands is a literal null
+     * @param {ASTNode} node The node to check
+     * @returns {boolean} if operands are null
+     * @private
+     */
+    function isNullCheck(node) {
+        return (node.right.type === "Literal" && node.right.value === null) ||
+                (node.left.type === "Literal" && node.left.value === null);
+    }
+
+    /**
+     * Gets the location (line and column) of the binary expression's operator
+     * @param {ASTNode} node The binary expression node to check
+     * @param {String} operator The operator to find
+     * @returns {Object} { line, column } location of operator
+     * @private
+     */
+    function getOperatorLocation(node) {
+        var opToken = context.getTokenAfter(node.left);
+        return {line: opToken.loc.start.line, column: opToken.loc.start.column};
+    }
+
+    return {
+        "BinaryExpression": function(node) {
+            if (node.operator !== "==" && node.operator !== "!=") {
+                return;
+            }
+
+            if (context.options[0] === "smart" && (isTypeOfBinary(node) ||
+                    areLiteralsAndSameType(node)) || isNullCheck(node)) {
+                return;
+            }
+
+            if (context.options[0] === "allow-null" && isNullCheck(node)) {
+                return;
+            }
+
+            context.report(
+                node, getOperatorLocation(node),
+                "Expected '{{op}}=' and instead saw '{{op}}'.",
+                {op: node.operator}
+            );
+        }
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["smart", "allow-null"]
+    }
+];

package/lib/rules/func-names.js

@@ -1,45 +1,45 @@
-/**
- * @fileoverview Rule to warn when a function expression does not have a name.
- * @author Kyle T. Nunery
- * @copyright 2015 Brandon Mills. All rights reserved.
- * @copyright 2014 Kyle T. Nunery. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * Determines whether the current FunctionExpression node is a get, set, or
-     * shorthand method in an object literal or a class.
-     * @returns {boolean} True if the node is a get, set, or shorthand method.
-     */
-    function isObjectOrClassMethod() {
-        var parent = context.getAncestors().pop();
-
-        return (parent.type === "MethodDefinition" || (
-            parent.type === "Property" && (
-                parent.method ||
-                parent.kind === "get" ||
-                parent.kind === "set"
-            )
-        ));
-    }
-
-    return {
-        "FunctionExpression": function(node) {
-
-            var name = node.id && node.id.name;
-
-            if (!name && !isObjectOrClassMethod()) {
-                context.report(node, "Missing function expression name.");
-            }
-        }
-    };
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to warn when a function expression does not have a name.
+ * @author Kyle T. Nunery
+ * @copyright 2015 Brandon Mills. All rights reserved.
+ * @copyright 2014 Kyle T. Nunery. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Determines whether the current FunctionExpression node is a get, set, or
+     * shorthand method in an object literal or a class.
+     * @returns {boolean} True if the node is a get, set, or shorthand method.
+     */
+    function isObjectOrClassMethod() {
+        var parent = context.getAncestors().pop();
+
+        return (parent.type === "MethodDefinition" || (
+            parent.type === "Property" && (
+                parent.method ||
+                parent.kind === "get" ||
+                parent.kind === "set"
+            )
+        ));
+    }
+
+    return {
+        "FunctionExpression": function(node) {
+
+            var name = node.id && node.id.name;
+
+            if (!name && !isObjectOrClassMethod()) {
+                context.report(node, "Missing function expression name.");
+            }
+        }
+    };
+};
+
+module.exports.schema = [];