eslint 0.22.0 → 0.24.1

package/lib/rules/no-undef.js

@@ -1,92 +1,92 @@
-/**
- * @fileoverview Rule to flag references to undeclared variables.
- * @author Mark Macdonald
- * @copyright 2015 Nicholas C. Zakas. All rights reserved.
- * @copyright 2013 Mark Macdonald. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-// none!
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-function isImplicitGlobal(variable) {
-    return variable.defs.every(function(def) {
-        return def.type === "ImplicitGlobalVariable";
-    });
-}
-
-/**
- * Gets the declared variable, defined in `scope`, that `ref` refers to.
- * @param {Scope} scope The scope in which to search.
- * @param {Reference} ref The reference to find in the scope.
- * @returns {Variable} The variable, or null if ref refers to an undeclared variable.
- */
-function getDeclaredGlobalVariable(scope, ref) {
-    var declaredGlobal = null;
-    scope.variables.some(function(variable) {
-        if (variable.name === ref.identifier.name) {
-            // If it's an implicit global, it must have a `writeable` field (indicating it was declared)
-            if (!isImplicitGlobal(variable) || {}.hasOwnProperty.call(variable, "writeable")) {
-                declaredGlobal = variable;
-                return true;
-            }
-        }
-        return false;
-    });
-    return declaredGlobal;
-}
-
-/**
- * Checks if the given node is the argument of a typeof operator.
- * @param {ASTNode} node The AST node being checked.
- * @returns {boolean} Whether or not the node is the argument of a typeof operator.
- */
-function hasTypeOfOperator(node) {
-    var parent = node.parent;
-    return parent.type === "UnaryExpression" && parent.operator === "typeof";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var NOT_DEFINED_MESSAGE = "\"{{name}}\" is not defined.",
-        READ_ONLY_MESSAGE = "\"{{name}}\" is read only.";
-
-    return {
-
-        "Program:exit": function(/*node*/) {
-
-            var globalScope = context.getScope();
-
-            globalScope.through.forEach(function(ref) {
-                var variable = getDeclaredGlobalVariable(globalScope, ref),
-                    name = ref.identifier.name;
-
-                if (hasTypeOfOperator(ref.identifier)) {
-                    return;
-                }
-
-                if (!variable) {
-                    context.report(ref.identifier, NOT_DEFINED_MESSAGE, { name: name });
-                } else if (ref.isWrite() && variable.writeable === false) {
-                    context.report(ref.identifier, READ_ONLY_MESSAGE, { name: name });
-                }
-            });
-
-        }
-
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag references to undeclared variables.
+ * @author Mark Macdonald
+ * @copyright 2015 Nicholas C. Zakas. All rights reserved.
+ * @copyright 2013 Mark Macdonald. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+// none!
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+function isImplicitGlobal(variable) {
+    return variable.defs.every(function(def) {
+        return def.type === "ImplicitGlobalVariable";
+    });
+}
+
+/**
+ * Gets the declared variable, defined in `scope`, that `ref` refers to.
+ * @param {Scope} scope The scope in which to search.
+ * @param {Reference} ref The reference to find in the scope.
+ * @returns {Variable} The variable, or null if ref refers to an undeclared variable.
+ */
+function getDeclaredGlobalVariable(scope, ref) {
+    var declaredGlobal = null;
+    scope.variables.some(function(variable) {
+        if (variable.name === ref.identifier.name) {
+            // If it's an implicit global, it must have a `writeable` field (indicating it was declared)
+            if (!isImplicitGlobal(variable) || {}.hasOwnProperty.call(variable, "writeable")) {
+                declaredGlobal = variable;
+                return true;
+            }
+        }
+        return false;
+    });
+    return declaredGlobal;
+}
+
+/**
+ * Checks if the given node is the argument of a typeof operator.
+ * @param {ASTNode} node The AST node being checked.
+ * @returns {boolean} Whether or not the node is the argument of a typeof operator.
+ */
+function hasTypeOfOperator(node) {
+    var parent = node.parent;
+    return parent.type === "UnaryExpression" && parent.operator === "typeof";
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var NOT_DEFINED_MESSAGE = "\"{{name}}\" is not defined.",
+        READ_ONLY_MESSAGE = "\"{{name}}\" is read only.";
+
+    return {
+
+        "Program:exit": function(/*node*/) {
+
+            var globalScope = context.getScope();
+
+            globalScope.through.forEach(function(ref) {
+                var variable = getDeclaredGlobalVariable(globalScope, ref),
+                    name = ref.identifier.name;
+
+                if (hasTypeOfOperator(ref.identifier)) {
+                    return;
+                }
+
+                if (!variable) {
+                    context.report(ref.identifier, NOT_DEFINED_MESSAGE, { name: name });
+                } else if (ref.isWrite() && variable.writeable === false) {
+                    context.report(ref.identifier, READ_ONLY_MESSAGE, { name: name });
+                }
+            });
+
+        }
+
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-undefined.js

@@ -1,27 +1,27 @@
-/**
- * @fileoverview Rule to flag references to the undefined variable.
- * @author Michael Ficarra
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "Identifier": function(node) {
-            if (node.name === "undefined") {
-                var parent = context.getAncestors().pop();
-                if (!parent || parent.type !== "MemberExpression" || node !== parent.property || parent.computed) {
-                    context.report(node, "Unexpected use of undefined.");
-                }
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag references to the undefined variable.
+ * @author Michael Ficarra
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "Identifier": function(node) {
+            if (node.name === "undefined") {
+                var parent = context.getAncestors().pop();
+                if (!parent || parent.type !== "MemberExpression" || node !== parent.property || parent.computed) {
+                    context.report(node, "Unexpected use of undefined.");
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-underscore-dangle.js

@@ -1,73 +1,73 @@
-/**
- * @fileoverview Rule to flag trailing underscores in variable declarations.
- * @author Matt DuVall <http://www.mattduvall.com>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    //-------------------------------------------------------------------------
-    // Helpers
-    //-------------------------------------------------------------------------
-
-    function hasTrailingUnderscore(identifier) {
-        var len = identifier.length;
-
-        return identifier !== "_" && (identifier[0] === "_" || identifier[len - 1] === "_");
-    }
-
-    function isSpecialCaseIdentifierForMemberExpression(identifier) {
-        return identifier === "__proto__";
-    }
-
-    function isSpecialCaseIdentifierInVariableExpression(identifier) {
-        // Checks for the underscore library usage here
-        return identifier === "_";
-    }
-
-    function checkForTrailingUnderscoreInFunctionDeclaration(node) {
-        if (node.id) {
-            var identifier = node.id.name;
-
-            if (typeof identifier !== "undefined" && hasTrailingUnderscore(identifier)) {
-                context.report(node, "Unexpected dangling \"_\" in \"" + identifier + "\".");
-            }
-        }
-    }
-
-    function checkForTrailingUnderscoreInVariableExpression(node) {
-        var identifier = node.id.name;
-
-        if (typeof identifier !== "undefined" && hasTrailingUnderscore(identifier) &&
-            !isSpecialCaseIdentifierInVariableExpression(identifier)) {
-            context.report(node, "Unexpected dangling \"_\" in \"" + identifier + "\".");
-        }
-    }
-
-    function checkForTrailingUnderscoreInMemberExpression(node) {
-        var identifier = node.property.name;
-
-        if (typeof identifier !== "undefined" && hasTrailingUnderscore(identifier) &&
-            !isSpecialCaseIdentifierForMemberExpression(identifier)) {
-            context.report(node, "Unexpected dangling \"_\" in \"" + identifier + "\".");
-        }
-    }
-
-    //--------------------------------------------------------------------------
-    // Public API
-    //--------------------------------------------------------------------------
-
-    return {
-        "FunctionDeclaration": checkForTrailingUnderscoreInFunctionDeclaration,
-        "VariableDeclarator": checkForTrailingUnderscoreInVariableExpression,
-        "MemberExpression": checkForTrailingUnderscoreInMemberExpression
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag trailing underscores in variable declarations.
+ * @author Matt DuVall <http://www.mattduvall.com>
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //-------------------------------------------------------------------------
+    // Helpers
+    //-------------------------------------------------------------------------
+
+    function hasTrailingUnderscore(identifier) {
+        var len = identifier.length;
+
+        return identifier !== "_" && (identifier[0] === "_" || identifier[len - 1] === "_");
+    }
+
+    function isSpecialCaseIdentifierForMemberExpression(identifier) {
+        return identifier === "__proto__";
+    }
+
+    function isSpecialCaseIdentifierInVariableExpression(identifier) {
+        // Checks for the underscore library usage here
+        return identifier === "_";
+    }
+
+    function checkForTrailingUnderscoreInFunctionDeclaration(node) {
+        if (node.id) {
+            var identifier = node.id.name;
+
+            if (typeof identifier !== "undefined" && hasTrailingUnderscore(identifier)) {
+                context.report(node, "Unexpected dangling \"_\" in \"" + identifier + "\".");
+            }
+        }
+    }
+
+    function checkForTrailingUnderscoreInVariableExpression(node) {
+        var identifier = node.id.name;
+
+        if (typeof identifier !== "undefined" && hasTrailingUnderscore(identifier) &&
+            !isSpecialCaseIdentifierInVariableExpression(identifier)) {
+            context.report(node, "Unexpected dangling \"_\" in \"" + identifier + "\".");
+        }
+    }
+
+    function checkForTrailingUnderscoreInMemberExpression(node) {
+        var identifier = node.property.name;
+
+        if (typeof identifier !== "undefined" && hasTrailingUnderscore(identifier) &&
+            !isSpecialCaseIdentifierForMemberExpression(identifier)) {
+            context.report(node, "Unexpected dangling \"_\" in \"" + identifier + "\".");
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Public API
+    //--------------------------------------------------------------------------
+
+    return {
+        "FunctionDeclaration": checkForTrailingUnderscoreInFunctionDeclaration,
+        "VariableDeclarator": checkForTrailingUnderscoreInVariableExpression,
+        "MemberExpression": checkForTrailingUnderscoreInMemberExpression
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-unexpected-multiline.js

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Rule to spot scenarios where a newline looks like it is ending a statement, but is not.
+ * @author Glen Mailer
+ * @copyright 2015 Glen Mailer
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+module.exports = function(context) {
+
+    var FUNCTION_MESSAGE = "Unexpected newline between function and ( of function call.";
+    var PROPERTY_MESSAGE = "Unexpected newline between object and [ of property access.";
+
+    /**
+     * Check to see if the bracket prior to the node is continuing the previous
+     * line's expression
+     * @param {ASTNode} node The node to check.
+     * @param {string} msg The error message to use.
+     * @returns {void}
+     * @private
+     */
+    function checkForBreakBefore(node, msg) {
+        var tokens = context.getTokensBefore(node, 2);
+        var paren = tokens[1];
+        var before = tokens[0];
+        if (paren.loc.start.line !== before.loc.end.line) {
+            context.report(node, paren.loc.start, msg, { char: paren.value });
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Public API
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "MemberExpression": function(node) {
+            if (!node.computed) {
+                return;
+            }
+
+            checkForBreakBefore(node.property, PROPERTY_MESSAGE);
+        },
+
+        "CallExpression": function(node) {
+            if (node.arguments.length === 0) {
+                return;
+            }
+
+            checkForBreakBefore(node.arguments[0], FUNCTION_MESSAGE);
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-unneeded-ternary.js

@@ -1,48 +1,48 @@
-/**
- * @fileoverview Rule to flag no-unneeded-ternary
- * @author Gyandeep Singh
- * @copyright 2015 Gyandeep Singh. All rights reserved.
- * @copyright 2015 Michael Ficarra. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * Reports an AST node as a rule violation.
-     * @param {ASTNode} mainNode The node to report.
-     * @param {object} culpritNode - The token which has a problem
-     * @returns {void}
-     * @private
-     */
-    function report(mainNode, culpritNode) {
-        context.report(mainNode, culpritNode.loc.start, "Unnecessary use of boolean literals in conditional expression");
-    }
-
-    /**
-     * Test if the node is a boolean literal
-     * @param {ASTNode} node - The node to report.
-     * @returns {boolean} True if the its a boolean literal
-     * @private
-     */
-    function isBooleanLiteral(node) {
-        return node.type === "Literal" && typeof node.value === "boolean";
-    }
-
-    return {
-
-        "ConditionalExpression": function(node) {
-
-            if (isBooleanLiteral(node.alternate) && isBooleanLiteral(node.consequent)) {
-                report(node, node.consequent);
-            }
-        }
-    };
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag no-unneeded-ternary
+ * @author Gyandeep Singh
+ * @copyright 2015 Gyandeep Singh. All rights reserved.
+ * @copyright 2015 Michael Ficarra. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Reports an AST node as a rule violation.
+     * @param {ASTNode} mainNode The node to report.
+     * @param {object} culpritNode - The token which has a problem
+     * @returns {void}
+     * @private
+     */
+    function report(mainNode, culpritNode) {
+        context.report(mainNode, culpritNode.loc.start, "Unnecessary use of boolean literals in conditional expression");
+    }
+
+    /**
+     * Test if the node is a boolean literal
+     * @param {ASTNode} node - The node to report.
+     * @returns {boolean} True if the its a boolean literal
+     * @private
+     */
+    function isBooleanLiteral(node) {
+        return node.type === "Literal" && typeof node.value === "boolean";
+    }
+
+    return {
+
+        "ConditionalExpression": function(node) {
+
+            if (isBooleanLiteral(node.alternate) && isBooleanLiteral(node.consequent)) {
+                report(node, node.consequent);
+            }
+        }
+    };
+};
+
+module.exports.schema = [];