eslint 0.22.0 → 0.24.1

package/lib/rules/computed-property-spacing.js

@@ -0,0 +1,144 @@
+/**
+ * @fileoverview Disallows or enforces spaces inside computed properties.
+ * @author Jamund Ferguson
+ * @copyright 2015 Jamund Ferguson. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+    var propertyNameMustBeSpaced = context.options[0] === "always"; // default is "never"
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Determines whether two adjacent tokens are have whitespace between them.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not there is space between the tokens.
+     */
+    function isSpaced(left, right) {
+        return left.range[1] < right.range[0];
+    }
+
+    /**
+     * Determines whether two adjacent tokens are on the same line.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not the tokens are on the same line.
+     */
+    function isSameLine(left, right) {
+        return left.loc.start.line === right.loc.start.line;
+    }
+
+    /**
+    * Reports that there shouldn't be a space after the first token
+    * @param {ASTNode} node - The node to report in the event of an error.
+    * @param {Token} token - The token to use for the report.
+    * @returns {void}
+    */
+    function reportNoBeginningSpace(node, token) {
+        context.report(node, token.loc.start,
+            "There should be no space after '" + token.value + "'");
+    }
+
+    /**
+    * Reports that there shouldn't be a space before the last token
+    * @param {ASTNode} node - The node to report in the event of an error.
+    * @param {Token} token - The token to use for the report.
+    * @returns {void}
+    */
+    function reportNoEndingSpace(node, token) {
+        context.report(node, token.loc.start,
+            "There should be no space before '" + token.value + "'");
+    }
+
+    /**
+    * Reports that there should be a space after the first token
+    * @param {ASTNode} node - The node to report in the event of an error.
+    * @param {Token} token - The token to use for the report.
+    * @returns {void}
+    */
+    function reportRequiredBeginningSpace(node, token) {
+        context.report(node, token.loc.start,
+            "A space is required after '" + token.value + "'");
+    }
+
+    /**
+    * Reports that there should be a space before the last token
+    * @param {ASTNode} node - The node to report in the event of an error.
+    * @param {Token} token - The token to use for the report.
+    * @returns {void}
+    */
+    function reportRequiredEndingSpace(node, token) {
+        context.report(node, token.loc.start,
+                    "A space is required before '" + token.value + "'");
+    }
+
+    /**
+     * Returns a function that checks the spacing of a node on the property name
+     * that was passed in.
+     * @param {String} propertyName The property on the node to check for spacing
+     * @returns {Function} A function that will check spacing on a node
+     */
+    function checkSpacing(propertyName) {
+        return function(node) {
+            if (!node.computed) {
+                return;
+            }
+
+            var property = node[propertyName];
+
+            var before = context.getTokenBefore(property),
+                first = context.getFirstToken(property),
+                last = context.getLastToken(property),
+                after = context.getTokenAfter(property);
+
+            if (isSameLine(before, first)) {
+                if (propertyNameMustBeSpaced) {
+                    if (!isSpaced(before, first) && isSameLine(before, first)) {
+                        reportRequiredBeginningSpace(node, before);
+                    }
+                } else {
+                    if (isSpaced(before, first)) {
+                        reportNoBeginningSpace(node, before);
+                    }
+                }
+            }
+
+            if (isSameLine(last, after)) {
+                if (propertyNameMustBeSpaced) {
+                    if (!isSpaced(last, after) && isSameLine(last, after)) {
+                        reportRequiredEndingSpace(node, after);
+                    }
+                } else {
+                    if (isSpaced(last, after)) {
+                        reportNoEndingSpace(node, after);
+                    }
+                }
+            }
+        };
+    }
+
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+        Property: checkSpacing("key"),
+        MemberExpression: checkSpacing("property")
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["always", "never"]
+    }
+];

package/lib/rules/consistent-return.js

@@ -1,75 +1,75 @@
-/**
- * @fileoverview Rule to flag consistent return values
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var functions = [];
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /**
-     * Marks entrance into a function by pushing a new object onto the functions
-     * stack.
-     * @returns {void}
-     * @private
-     */
-    function enterFunction() {
-        functions.push({});
-    }
-
-    /**
-     * Marks exit of a function by popping off the functions stack.
-     * @returns {void}
-     * @private
-     */
-    function exitFunction() {
-        functions.pop();
-    }
-
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    return {
-
-        "Program": enterFunction,
-        "FunctionDeclaration": enterFunction,
-        "FunctionExpression": enterFunction,
-        "ArrowFunctionExpression": enterFunction,
-
-        "Program:exit": exitFunction,
-        "FunctionDeclaration:exit": exitFunction,
-        "FunctionExpression:exit": exitFunction,
-        "ArrowFunctionExpression:exit": exitFunction,
-
-        "ReturnStatement": function(node) {
-
-            var returnInfo = functions[functions.length - 1],
-                returnTypeDefined = "type" in returnInfo;
-
-            if (returnTypeDefined) {
-
-                if (returnInfo.type !== !!node.argument) {
-                    context.report(node, "Expected " + (returnInfo.type ? "a" : "no") + " return value.");
-                }
-
-            } else {
-                returnInfo.type = !!node.argument;
-            }
-
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag consistent return values
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var functions = [];
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Marks entrance into a function by pushing a new object onto the functions
+     * stack.
+     * @returns {void}
+     * @private
+     */
+    function enterFunction() {
+        functions.push({});
+    }
+
+    /**
+     * Marks exit of a function by popping off the functions stack.
+     * @returns {void}
+     * @private
+     */
+    function exitFunction() {
+        functions.pop();
+    }
+
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "Program": enterFunction,
+        "FunctionDeclaration": enterFunction,
+        "FunctionExpression": enterFunction,
+        "ArrowFunctionExpression": enterFunction,
+
+        "Program:exit": exitFunction,
+        "FunctionDeclaration:exit": exitFunction,
+        "FunctionExpression:exit": exitFunction,
+        "ArrowFunctionExpression:exit": exitFunction,
+
+        "ReturnStatement": function(node) {
+
+            var returnInfo = functions[functions.length - 1],
+                returnTypeDefined = "type" in returnInfo;
+
+            if (returnTypeDefined) {
+
+                if (returnInfo.type !== !!node.argument) {
+                    context.report(node, "Expected " + (returnInfo.type ? "a" : "no") + " return value.");
+                }
+
+            } else {
+                returnInfo.type = !!node.argument;
+            }
+
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/consistent-this.js

@@ -1,119 +1,119 @@
-/**
- * @fileoverview Rule to enforce consistent naming of "this" context variables
- * @author Raphael Pigulla
- * @copyright 2015 Timothy Jones. All rights reserved.
- * @copyright 2015 David Aurelio. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-    var alias = context.options[0];
-
-    /**
-     * Reports that a variable declarator or assignment expression is assigning
-     * a non-'this' value to the specified alias.
-     * @param {ASTNode} node - The assigning node.
-     * @returns {void}
-     */
-    function reportBadAssignment(node) {
-        context.report(node,
-            "Designated alias '{{alias}}' is not assigned to 'this'.",
-            { alias: alias });
-    }
-
-    /**
-     * Checks that an assignment to an identifier only assigns 'this' to the
-     * appropriate alias, and the alias is only assigned to 'this'.
-     * @param {ASTNode} node - The assigning node.
-     * @param {Identifier} name - The name of the variable assigned to.
-     * @param {Expression} value - The value of the assignment.
-     * @returns {void}
-     */
-    function checkAssignment(node, name, value) {
-        var isThis = value.type === "ThisExpression";
-
-        if (name === alias) {
-            if (!isThis || node.operator && node.operator !== "=") {
-                reportBadAssignment(node);
-            }
-        } else if (isThis) {
-            context.report(node,
-                "Unexpected alias '{{name}}' for 'this'.", { name: name });
-        }
-    }
-
-    /**
-     * Ensures that a variable declaration of the alias in a program or function
-     * is assigned to the correct value.
-     * @returns {void}
-     */
-    function ensureWasAssigned() {
-        var scope = context.getScope();
-
-        scope.variables.some(function (variable) {
-            var lookup;
-
-            if (variable.name === alias) {
-                if (variable.defs.some(function (def) {
-                    return def.node.type === "VariableDeclarator" &&
-                        def.node.init !== null;
-                })) {
-                    return true;
-                }
-
-                lookup = scope.type === "global" ? scope : variable;
-
-                // The alias has been declared and not assigned: check it was
-                // assigned later in the same scope.
-                if (!lookup.references.some(function (reference) {
-                    var write = reference.writeExpr;
-
-                    if (reference.from === scope &&
-                            write && write.type === "ThisExpression" &&
-                            write.parent.operator === "=") {
-                        return true;
-                    }
-                })) {
-                    variable.defs.map(function (def) {
-                        return def.node;
-                    }).forEach(reportBadAssignment);
-                }
-
-                return true;
-            }
-        });
-    }
-
-    return {
-        "Program:exit": ensureWasAssigned,
-        "FunctionExpression:exit": ensureWasAssigned,
-        "FunctionDeclaration:exit": ensureWasAssigned,
-
-        "VariableDeclarator": function (node) {
-            var id = node.id;
-            var isDestructuring =
-                id.type === "ArrayPattern" || id.type === "ObjectPattern";
-
-            if (node.init !== null && !isDestructuring) {
-                checkAssignment(node, id.name, node.init);
-            }
-        },
-
-        "AssignmentExpression": function (node) {
-            if (node.left.type === "Identifier") {
-                checkAssignment(node, node.left.name, node.right);
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "type": "string"
-    }
-];
+/**
+ * @fileoverview Rule to enforce consistent naming of "this" context variables
+ * @author Raphael Pigulla
+ * @copyright 2015 Timothy Jones. All rights reserved.
+ * @copyright 2015 David Aurelio. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+    var alias = context.options[0];
+
+    /**
+     * Reports that a variable declarator or assignment expression is assigning
+     * a non-'this' value to the specified alias.
+     * @param {ASTNode} node - The assigning node.
+     * @returns {void}
+     */
+    function reportBadAssignment(node) {
+        context.report(node,
+            "Designated alias '{{alias}}' is not assigned to 'this'.",
+            { alias: alias });
+    }
+
+    /**
+     * Checks that an assignment to an identifier only assigns 'this' to the
+     * appropriate alias, and the alias is only assigned to 'this'.
+     * @param {ASTNode} node - The assigning node.
+     * @param {Identifier} name - The name of the variable assigned to.
+     * @param {Expression} value - The value of the assignment.
+     * @returns {void}
+     */
+    function checkAssignment(node, name, value) {
+        var isThis = value.type === "ThisExpression";
+
+        if (name === alias) {
+            if (!isThis || node.operator && node.operator !== "=") {
+                reportBadAssignment(node);
+            }
+        } else if (isThis) {
+            context.report(node,
+                "Unexpected alias '{{name}}' for 'this'.", { name: name });
+        }
+    }
+
+    /**
+     * Ensures that a variable declaration of the alias in a program or function
+     * is assigned to the correct value.
+     * @returns {void}
+     */
+    function ensureWasAssigned() {
+        var scope = context.getScope();
+
+        scope.variables.some(function (variable) {
+            var lookup;
+
+            if (variable.name === alias) {
+                if (variable.defs.some(function (def) {
+                    return def.node.type === "VariableDeclarator" &&
+                        def.node.init !== null;
+                })) {
+                    return true;
+                }
+
+                lookup = scope.type === "global" ? scope : variable;
+
+                // The alias has been declared and not assigned: check it was
+                // assigned later in the same scope.
+                if (!lookup.references.some(function (reference) {
+                    var write = reference.writeExpr;
+
+                    if (reference.from === scope &&
+                            write && write.type === "ThisExpression" &&
+                            write.parent.operator === "=") {
+                        return true;
+                    }
+                })) {
+                    variable.defs.map(function (def) {
+                        return def.node;
+                    }).forEach(reportBadAssignment);
+                }
+
+                return true;
+            }
+        });
+    }
+
+    return {
+        "Program:exit": ensureWasAssigned,
+        "FunctionExpression:exit": ensureWasAssigned,
+        "FunctionDeclaration:exit": ensureWasAssigned,
+
+        "VariableDeclarator": function (node) {
+            var id = node.id;
+            var isDestructuring =
+                id.type === "ArrayPattern" || id.type === "ObjectPattern";
+
+            if (node.init !== null && !isDestructuring) {
+                checkAssignment(node, id.name, node.init);
+            }
+        },
+
+        "AssignmentExpression": function (node) {
+            if (node.left.type === "Identifier") {
+                checkAssignment(node, node.left.name, node.right);
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "type": "string"
+    }
+];

package/lib/rules/constructor-super.js

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview A rule to verify `super()` callings in constructor.
+ * @author Toru Nagashima
+ * @copyright 2015 Toru Nagashima. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Searches a class node from ancestors of a node.
+     * @param {Node} node - A node to get.
+     * @returns {ClassDeclaration|ClassExpression|null} the found class node or `null`.
+     */
+    function getClassInAncestor(node) {
+        while (node != null) {
+            if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+                return node;
+            }
+            node = node.parent;
+        }
+        /* istanbul ignore next */
+        return null;
+    }
+
+    /**
+     * Checks whether or not a node is the null literal.
+     * @param {Node} node - A node to check.
+     * @returns {boolean} whether or not a node is the null literal.
+     */
+    function isNullLiteral(node) {
+        return node != null && node.type === "Literal" && node.value === null;
+    }
+
+    /**
+     * Checks whether or not the current traversal context is on constructors.
+     * @param {{scope: Scope}} item - A checking context to check.
+     * @returns {boolean} whether or not the current traversal context is on constructors.
+     */
+    function isOnConstructor(item) {
+        return item != null && item.scope === context.getScope().variableScope.upper.variableScope;
+    }
+
+    // A stack for checking context.
+    var stack = [];
+
+    return {
+        /**
+         * Start checking.
+         * @param {MethodDefinition} node - A target node.
+         * @returns {void}
+         */
+        "MethodDefinition": function(node) {
+            if (node.kind !== "constructor") {
+                return;
+            }
+            stack.push({
+                superCallings: [],
+                scope: context.getScope().variableScope
+            });
+        },
+
+        /**
+         * Checks the result, then reports invalid/missing `super()`.
+         * @param {MethodDefinition} node - A target node.
+         * @returns {void}
+         */
+        "MethodDefinition:exit": function(node) {
+            if (node.kind !== "constructor") {
+                return;
+            }
+            var result = stack.pop();
+
+            var classNode = getClassInAncestor(node);
+            /* istanbul ignore if */
+            if (classNode == null) {
+                return;
+            }
+
+            if (classNode.superClass === null || isNullLiteral(classNode.superClass)) {
+                result.superCallings.forEach(function(superCalling) {
+                    context.report(superCalling, "unexpected `super()`.");
+                });
+            } else if (result.superCallings.length === 0) {
+                context.report(node.key, "this constructor requires `super()`.");
+            }
+        },
+
+        /**
+         * Checks the result of checking, then reports invalid/missing `super()`.
+         * @param {MethodDefinition} node - A target node.
+         * @returns {void}
+         */
+        "CallExpression": function(node) {
+            var item = stack[stack.length - 1];
+            if (isOnConstructor(item) && node.callee.type === "Super") {
+                item.superCallings.push(node);
+            }
+        }
+    };
+};
+
+module.exports.schema = [];