eslint 0.22.0 → 0.24.1

package/lib/rules/no-extra-semi.js

@@ -1,23 +1,70 @@
-/**
- * @fileoverview Rule to flag use of unnecessary semicolons
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "EmptyStatement": function(node) {
-            context.report(node, "Unnecessary semicolon.");
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of unnecessary semicolons
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Reports an unnecessary semicolon error.
+     * @param {Node|Token} nodeOrToken - A node or a token to be reported.
+     * @returns {void}
+     */
+    function report(nodeOrToken) {
+        context.report(nodeOrToken, "Unnecessary semicolon.");
+    }
+
+    /**
+     * Checks for a part of a class body.
+     * This checks tokens from a specified token to a next MethodDefinition or the end of class body.
+     *
+     * @param {Token} firstToken - The first token to check.
+     * @returns {void}
+     */
+    function checkForPartOfClassBody(firstToken) {
+        for (var token = firstToken;
+            token.type === "Punctuator" && token.value !== "}";
+            token = context.getTokenAfter(token)
+        ) {
+            if (token.value === ";") {
+                report(token);
+            }
+        }
+    }
+
+    return {
+        /**
+         * Reports this empty statement.
+         * @param {Node} node - A EmptyStatement node to be reported.
+         * @returns {void}
+         */
+        "EmptyStatement": report,
+
+        /**
+         * Checks tokens from the head of this class body to the first MethodDefinition or the end of this class body.
+         * @param {Node} node - A ClassBody node to check.
+         * @returns {void}
+         */
+        "ClassBody": function(node) {
+            checkForPartOfClassBody(context.getFirstToken(node, 1)); // 0 is `{`.
+        },
+
+        /**
+         * Checks tokens from this MethodDefinition to the next MethodDefinition or the end of this class body.
+         * @param {Node} node - A MethodDefinition node of the start point.
+         * @returns {void}
+         */
+        "MethodDefinition": function(node) {
+            checkForPartOfClassBody(context.getTokenAfter(node));
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-extra-strict.js

@@ -1,86 +1,86 @@
-/**
- * @fileoverview Rule to flag unnecessary strict directives.
- * @author Ian Christian Myers
- * @copyright 2014 Ian Christian Myers. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    function directives(block) {
-        var ds = [], body = block.body, e, i, l;
-
-        if (body) {
-            for (i = 0, l = body.length; i < l; ++i) {
-                e = body[i];
-
-                if (
-                    e.type === "ExpressionStatement" &&
-                    e.expression.type === "Literal" &&
-                    typeof e.expression.value === "string"
-                ) {
-                    ds.push(e.expression);
-                } else {
-                    break;
-                }
-            }
-        }
-
-        return ds;
-    }
-
-    function isStrict(directive) {
-        return directive.value === "use strict";
-    }
-
-    function checkForUnnecessaryUseStrict(node) {
-        var useStrictDirectives = directives(node).filter(isStrict),
-            scope,
-            upper;
-
-        switch (useStrictDirectives.length) {
-            case 0:
-                break;
-
-            case 1:
-                scope = context.getScope();
-                upper = scope.upper;
-
-                if (upper && upper.functionExpressionScope) {
-                    upper = upper.upper;
-                }
-
-                if (upper && upper.isStrict) {
-                    context.report(useStrictDirectives[0], "Unnecessary 'use strict'.");
-                }
-                break;
-
-            default:
-                context.report(useStrictDirectives[1], "Multiple 'use strict' directives.");
-        }
-    }
-
-    return {
-
-        "Program": checkForUnnecessaryUseStrict,
-
-        "ArrowFunctionExpression": function(node) {
-            checkForUnnecessaryUseStrict(node.body);
-        },
-
-        "FunctionExpression": function(node) {
-            checkForUnnecessaryUseStrict(node.body);
-        },
-
-        "FunctionDeclaration": function(node) {
-            checkForUnnecessaryUseStrict(node.body);
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag unnecessary strict directives.
+ * @author Ian Christian Myers
+ * @copyright 2014 Ian Christian Myers. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    function directives(block) {
+        var ds = [], body = block.body, e, i, l;
+
+        if (body) {
+            for (i = 0, l = body.length; i < l; ++i) {
+                e = body[i];
+
+                if (
+                    e.type === "ExpressionStatement" &&
+                    e.expression.type === "Literal" &&
+                    typeof e.expression.value === "string"
+                ) {
+                    ds.push(e.expression);
+                } else {
+                    break;
+                }
+            }
+        }
+
+        return ds;
+    }
+
+    function isStrict(directive) {
+        return directive.value === "use strict";
+    }
+
+    function checkForUnnecessaryUseStrict(node) {
+        var useStrictDirectives = directives(node).filter(isStrict),
+            scope,
+            upper;
+
+        switch (useStrictDirectives.length) {
+            case 0:
+                break;
+
+            case 1:
+                scope = context.getScope();
+                upper = scope.upper;
+
+                if (upper && upper.functionExpressionScope) {
+                    upper = upper.upper;
+                }
+
+                if (upper && upper.isStrict) {
+                    context.report(useStrictDirectives[0], "Unnecessary 'use strict'.");
+                }
+                break;
+
+            default:
+                context.report(useStrictDirectives[1], "Multiple 'use strict' directives.");
+        }
+    }
+
+    return {
+
+        "Program": checkForUnnecessaryUseStrict,
+
+        "ArrowFunctionExpression": function(node) {
+            checkForUnnecessaryUseStrict(node.body);
+        },
+
+        "FunctionExpression": function(node) {
+            checkForUnnecessaryUseStrict(node.body);
+        },
+
+        "FunctionDeclaration": function(node) {
+            checkForUnnecessaryUseStrict(node.body);
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-fallthrough.js

@@ -1,97 +1,97 @@
-/**
- * @fileoverview Rule to flag fall-through cases in switch statements.
- * @author Matt DuVall <http://mattduvall.com/>
- */
-"use strict";
-
-
-var FALLTHROUGH_COMMENT = /falls\sthrough/;
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var switches = [];
-
-    return {
-
-        "SwitchCase": function(node) {
-
-            var consequent = node.consequent,
-                switchData = switches[switches.length - 1],
-                i,
-                comments,
-                comment;
-
-            /*
-             * Some developers wrap case bodies in blocks, so if there is just one
-             * node and it's a block statement, check inside.
-             */
-            if (consequent.length === 1 && consequent[0].type === "BlockStatement") {
-                consequent = consequent[0];
-            }
-
-            // checking on previous case
-            if (!switchData.lastCaseClosed) {
-
-                // a fall through comment will be the last trailing comment of the last case
-                comments = context.getComments(switchData.lastCase).trailing;
-                comment = comments[comments.length - 1];
-
-                // unless the user doesn't like semicolons, in which case it's first leading comment of this case
-                if (!comment) {
-                    comments = context.getComments(node).leading;
-                    comment = comments[comments.length - 1];
-                }
-
-                // check for comment
-                if (!comment || !FALLTHROUGH_COMMENT.test(comment.value)) {
-
-                    context.report(switchData.lastCase,
-                        "Expected a \"break\" statement before \"{{code}}\".",
-                        { code: node.test ? "case" : "default" });
-                }
-            }
-
-            // now dealing with the current case
-            switchData.lastCaseClosed = false;
-            switchData.lastCase = node;
-
-            // try to verify using statements - go backwards as a fast path for the search
-            if (consequent.length) {
-                for (i = consequent.length - 1; i >= 0; i--) {
-                    if (/(?:Break|Continue|Return|Throw)Statement/.test(consequent[i].type)) {
-                        switchData.lastCaseClosed = true;
-                        break;
-                    }
-                }
-            } else {
-                // the case statement has no statements, so it must logically fall through
-                switchData.lastCaseClosed = true;
-            }
-
-            /*
-             * Any warnings are triggered when the next SwitchCase occurs.
-             * There is no need to warn on the last SwitchCase, since it can't
-             * fall through to anything.
-             */
-        },
-
-        "SwitchStatement": function(node) {
-            switches.push({
-                node: node,
-                lastCaseClosed: true,
-                lastCase: null
-            });
-        },
-
-        "SwitchStatement:exit": function() {
-            switches.pop();
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag fall-through cases in switch statements.
+ * @author Matt DuVall <http://mattduvall.com/>
+ */
+"use strict";
+
+
+var FALLTHROUGH_COMMENT = /falls\sthrough/;
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var switches = [];
+
+    return {
+
+        "SwitchCase": function(node) {
+
+            var consequent = node.consequent,
+                switchData = switches[switches.length - 1],
+                i,
+                comments,
+                comment;
+
+            /*
+             * Some developers wrap case bodies in blocks, so if there is just one
+             * node and it's a block statement, check inside.
+             */
+            if (consequent.length === 1 && consequent[0].type === "BlockStatement") {
+                consequent = consequent[0];
+            }
+
+            // checking on previous case
+            if (!switchData.lastCaseClosed) {
+
+                // a fall through comment will be the last trailing comment of the last case
+                comments = context.getComments(switchData.lastCase).trailing;
+                comment = comments[comments.length - 1];
+
+                // unless the user doesn't like semicolons, in which case it's first leading comment of this case
+                if (!comment) {
+                    comments = context.getComments(node).leading;
+                    comment = comments[comments.length - 1];
+                }
+
+                // check for comment
+                if (!comment || !FALLTHROUGH_COMMENT.test(comment.value)) {
+
+                    context.report(switchData.lastCase,
+                        "Expected a \"break\" statement before \"{{code}}\".",
+                        { code: node.test ? "case" : "default" });
+                }
+            }
+
+            // now dealing with the current case
+            switchData.lastCaseClosed = false;
+            switchData.lastCase = node;
+
+            // try to verify using statements - go backwards as a fast path for the search
+            if (consequent.length) {
+                for (i = consequent.length - 1; i >= 0; i--) {
+                    if (/(?:Break|Continue|Return|Throw)Statement/.test(consequent[i].type)) {
+                        switchData.lastCaseClosed = true;
+                        break;
+                    }
+                }
+            } else {
+                // the case statement has no statements, so it must logically fall through
+                switchData.lastCaseClosed = true;
+            }
+
+            /*
+             * Any warnings are triggered when the next SwitchCase occurs.
+             * There is no need to warn on the last SwitchCase, since it can't
+             * fall through to anything.
+             */
+        },
+
+        "SwitchStatement": function(node) {
+            switches.push({
+                node: node,
+                lastCaseClosed: true,
+                lastCase: null
+            });
+        },
+
+        "SwitchStatement:exit": function() {
+            switches.pop();
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-floating-decimal.js

@@ -1,30 +1,30 @@
-/**
- * @fileoverview Rule to flag use of a leading/trailing decimal point in a numeric literal
- * @author James Allardice
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-        "Literal": function(node) {
-
-            if (typeof node.value === "number") {
-                if (node.raw.indexOf(".") === 0) {
-                    context.report(node, "A leading decimal point can be confused with a dot.");
-                }
-                if (node.raw.indexOf(".") === node.raw.length - 1) {
-                    context.report(node, "A trailing decimal point can be confused with a dot.");
-                }
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of a leading/trailing decimal point in a numeric literal
+ * @author James Allardice
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+        "Literal": function(node) {
+
+            if (typeof node.value === "number") {
+                if (node.raw.indexOf(".") === 0) {
+                    context.report(node, "A leading decimal point can be confused with a dot.");
+                }
+                if (node.raw.indexOf(".") === node.raw.length - 1) {
+                    context.report(node, "A trailing decimal point can be confused with a dot.");
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];