eslint 0.22.0 → 0.24.1

package/lib/rules/func-style.js

@@ -1,49 +1,49 @@
-/**
- * @fileoverview Rule to enforce a particular function style
- * @author Nicholas C. Zakas
- * @copyright 2013 Nicholas C. Zakas. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var style = context.options[0],
-        enforceDeclarations = (style === "declaration");
-
-    return {
-
-        "FunctionDeclaration": function(node) {
-            if (!enforceDeclarations) {
-                context.report(node, "Expected a function expression.");
-            }
-        },
-
-        "FunctionExpression": function() {
-            var parent = context.getAncestors().pop();
-
-            if (enforceDeclarations && parent.type === "VariableDeclarator") {
-                context.report(parent, "Expected a function declaration.");
-            }
-        },
-
-        "ArrowFunctionExpression": function() {
-            var parent = context.getAncestors().pop();
-
-            if (enforceDeclarations && parent.type === "VariableDeclarator") {
-                context.report(parent, "Expected a function declaration.");
-            }
-        }
-
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["declaration", "expression"]
-    }
-];
+/**
+ * @fileoverview Rule to enforce a particular function style
+ * @author Nicholas C. Zakas
+ * @copyright 2013 Nicholas C. Zakas. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var style = context.options[0],
+        enforceDeclarations = (style === "declaration");
+
+    return {
+
+        "FunctionDeclaration": function(node) {
+            if (!enforceDeclarations) {
+                context.report(node, "Expected a function expression.");
+            }
+        },
+
+        "FunctionExpression": function() {
+            var parent = context.getAncestors().pop();
+
+            if (enforceDeclarations && parent.type === "VariableDeclarator") {
+                context.report(parent, "Expected a function declaration.");
+            }
+        },
+
+        "ArrowFunctionExpression": function() {
+            var parent = context.getAncestors().pop();
+
+            if (enforceDeclarations && parent.type === "VariableDeclarator") {
+                context.report(parent, "Expected a function declaration.");
+            }
+        }
+
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["declaration", "expression"]
+    }
+];

package/lib/rules/generator-star-spacing.js

@@ -1,87 +1,104 @@
-/**
- * @fileoverview Rule to check the spacing around the * in generator functions.
- * @author Jamund Ferguson
- * @copyright 2015 Brandon Mills. All rights reserved.
- * @copyright 2014 Jamund Ferguson. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var mode = {
-        before: { before: true, after: false },
-        after: { before: false, after: true },
-        both: { before: true, after: true },
-        neither: { before: false, after: false }
-    }[context.options[0] || "before"];
-
-    /**
-     * Checks the spacing between two tokens before or after the star token.
-     * @param {string} side Either "before" or "after".
-     * @param {Token} leftToken `function` keyword token if side is "before", or
-     *     star token if side is "after".
-     * @param {Token} rightToken Star token if side is "before", or identifier
-     *     token if side is "after".
-     * @returns {void}
-     */
-    function checkSpacing(side, leftToken, rightToken) {
-        if (!!(rightToken.range[0] - leftToken.range[1]) !== mode[side]) {
-            context.report(
-                leftToken.value === "*" ? leftToken : rightToken,
-                "{{type}} space {{side}} *.",
-                {
-                    type: mode[side] ? "Missing" : "Unexpected",
-                    side: side
-                }
-            );
-        }
-    }
-
-    /**
-     * Enforces the spacing around the star if node is a generator function.
-     * @param {ASTNode} node A function expression or declaration node.
-     * @returns {void}
-     */
-    function checkFunction(node) {
-        var prevToken, starToken, nextToken;
-
-        if (!node.generator) {
-            return;
-        }
-
-        if (node.parent.method || node.parent.type === "MethodDefinition") {
-            starToken = context.getTokenBefore(node, 1);
-        } else {
-            starToken = context.getFirstToken(node, 1);
-        }
-
-        // Only check before when preceded by `function` keyword
-        prevToken = context.getTokenBefore(starToken);
-        if (prevToken.value === "function" || prevToken.value === "static") {
-            checkSpacing("before", prevToken, starToken);
-        }
-
-        // Only check after when followed by an identifier
-        nextToken = context.getTokenAfter(starToken);
-        if (nextToken.type === "Identifier") {
-            checkSpacing("after", starToken, nextToken);
-        }
-    }
-
-    return {
-        "FunctionDeclaration": checkFunction,
-        "FunctionExpression": checkFunction
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["before", "after", "both", "neither"]
-    }
-];
+/**
+ * @fileoverview Rule to check the spacing around the * in generator functions.
+ * @author Jamund Ferguson
+ * @copyright 2015 Brandon Mills. All rights reserved.
+ * @copyright 2014 Jamund Ferguson. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var mode = (function(option) {
+        if (option == null || typeof option === "string") {
+            return {
+                before: { before: true, after: false },
+                after: { before: false, after: true },
+                both: { before: true, after: true },
+                neither: { before: false, after: false }
+            }[option || "before"];
+        }
+        return option;
+    }(context.options[0]));
+
+    /**
+     * Checks the spacing between two tokens before or after the star token.
+     * @param {string} side Either "before" or "after".
+     * @param {Token} leftToken `function` keyword token if side is "before", or
+     *     star token if side is "after".
+     * @param {Token} rightToken Star token if side is "before", or identifier
+     *     token if side is "after".
+     * @returns {void}
+     */
+    function checkSpacing(side, leftToken, rightToken) {
+        if (!!(rightToken.range[0] - leftToken.range[1]) !== mode[side]) {
+            context.report(
+                leftToken.value === "*" ? leftToken : rightToken,
+                "{{type}} space {{side}} *.",
+                {
+                    type: mode[side] ? "Missing" : "Unexpected",
+                    side: side
+                }
+            );
+        }
+    }
+
+    /**
+     * Enforces the spacing around the star if node is a generator function.
+     * @param {ASTNode} node A function expression or declaration node.
+     * @returns {void}
+     */
+    function checkFunction(node) {
+        var prevToken, starToken, nextToken;
+
+        if (!node.generator) {
+            return;
+        }
+
+        if (node.parent.method || node.parent.type === "MethodDefinition") {
+            starToken = context.getTokenBefore(node, 1);
+        } else {
+            starToken = context.getFirstToken(node, 1);
+        }
+
+        // Only check before when preceded by `function` keyword
+        prevToken = context.getTokenBefore(starToken);
+        if (prevToken.value === "function" || prevToken.value === "static") {
+            checkSpacing("before", prevToken, starToken);
+        }
+
+        // Only check after when followed by an identifier
+        nextToken = context.getTokenAfter(starToken);
+        if (nextToken.type === "Identifier") {
+            checkSpacing("after", starToken, nextToken);
+        }
+    }
+
+    return {
+        "FunctionDeclaration": checkFunction,
+        "FunctionExpression": checkFunction
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "oneOf": [
+            {
+                "enum": ["before", "after", "both", "neither"]
+            },
+            {
+                "type": "object",
+                "properties": {
+                    "before": {"type": "boolean"},
+                    "after": {"type": "boolean"}
+                },
+                "additionalProperties": false
+            }
+        ]
+    }
+];

package/lib/rules/generator-star.js

@@ -1,76 +1,76 @@
-/**
- * @fileoverview Rule to check for the position of the * in your generator functions
- * @author Jamund Ferguson
- * @copyright 2014 Jamund Ferguson. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var position = context.options[0] || "end";
-
-    /**
-     * Check the position of the star compared to the expected position.
-     * @param {ASTNode} node - the entire function node
-     * @returns {void}
-     */
-    function checkStarPosition(node) {
-        var starToken;
-
-        if (!node.generator) {
-            return;
-        }
-
-        // Blocked, pending decision to fix or work around in eslint/espree#36
-        if (context.getAncestors().pop().method) {
-            return;
-        }
-
-        starToken = context.getFirstToken(node, 1);
-
-        // check for function *name() {}
-        if (position === "end") {
-
-            // * starts where the next identifier begins
-            if (starToken.range[1] !== context.getTokenAfter(starToken).range[0]) {
-                context.report(node, "Expected a space before *.");
-            }
-        }
-
-        // check for function* name() {}
-        if (position === "start") {
-
-            // * begins where the previous identifier ends
-            if (starToken.range[0] !== context.getTokenBefore(starToken).range[1]) {
-                context.report(node, "Expected no space before *.");
-            }
-        }
-
-        // check for function * name() {}
-        if (position === "middle") {
-
-            // must be a space before and afer the *
-            if (starToken.range[0] <= context.getTokenBefore(starToken).range[1] ||
-                starToken.range[1] >= context.getTokenAfter(starToken).range[0]) {
-                context.report(node, "Expected spaces around *.");
-            }
-        }
-    }
-
-    return {
-        "FunctionDeclaration": checkStarPosition,
-        "FunctionExpression": checkStarPosition
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["start", "middle", "end"]
-    }
-];
+/**
+ * @fileoverview Rule to check for the position of the * in your generator functions
+ * @author Jamund Ferguson
+ * @copyright 2014 Jamund Ferguson. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var position = context.options[0] || "end";
+
+    /**
+     * Check the position of the star compared to the expected position.
+     * @param {ASTNode} node - the entire function node
+     * @returns {void}
+     */
+    function checkStarPosition(node) {
+        var starToken;
+
+        if (!node.generator) {
+            return;
+        }
+
+        // Blocked, pending decision to fix or work around in eslint/espree#36
+        if (context.getAncestors().pop().method) {
+            return;
+        }
+
+        starToken = context.getFirstToken(node, 1);
+
+        // check for function *name() {}
+        if (position === "end") {
+
+            // * starts where the next identifier begins
+            if (starToken.range[1] !== context.getTokenAfter(starToken).range[0]) {
+                context.report(node, "Expected a space before *.");
+            }
+        }
+
+        // check for function* name() {}
+        if (position === "start") {
+
+            // * begins where the previous identifier ends
+            if (starToken.range[0] !== context.getTokenBefore(starToken).range[1]) {
+                context.report(node, "Expected no space before *.");
+            }
+        }
+
+        // check for function * name() {}
+        if (position === "middle") {
+
+            // must be a space before and afer the *
+            if (starToken.range[0] <= context.getTokenBefore(starToken).range[1] ||
+                starToken.range[1] >= context.getTokenAfter(starToken).range[0]) {
+                context.report(node, "Expected spaces around *.");
+            }
+        }
+    }
+
+    return {
+        "FunctionDeclaration": checkStarPosition,
+        "FunctionExpression": checkStarPosition
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["start", "middle", "end"]
+    }
+];

package/lib/rules/global-strict.js

@@ -1,49 +1,49 @@
-/**
- * @fileoverview Rule to flag or require global strict mode.
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var mode = context.options[0];
-
-    if (mode === "always") {
-
-        return {
-            "Program": function(node) {
-                if (node.body.length > 0) {
-                    var statement = node.body[0];
-
-                    if (!(statement.type === "ExpressionStatement" && statement.expression.value === "use strict")) {
-                        context.report(node, "Use the global form of \"use strict\".");
-                    }
-                }
-            }
-        };
-
-    } else { // mode = "never"
-
-        return {
-            "ExpressionStatement": function(node) {
-                var parent = context.getAncestors().pop();
-
-                if (node.expression.value === "use strict" && parent.type === "Program") {
-                    context.report(node, "Use the function form of \"use strict\".");
-                }
-            }
-        };
-
-    }
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["always", "never"]
-    }
-];
+/**
+ * @fileoverview Rule to flag or require global strict mode.
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var mode = context.options[0];
+
+    if (mode === "always") {
+
+        return {
+            "Program": function(node) {
+                if (node.body.length > 0) {
+                    var statement = node.body[0];
+
+                    if (!(statement.type === "ExpressionStatement" && statement.expression.value === "use strict")) {
+                        context.report(node, "Use the global form of \"use strict\".");
+                    }
+                }
+            }
+        };
+
+    } else { // mode = "never"
+
+        return {
+            "ExpressionStatement": function(node) {
+                var parent = context.getAncestors().pop();
+
+                if (node.expression.value === "use strict" && parent.type === "Program") {
+                    context.report(node, "Use the function form of \"use strict\".");
+                }
+            }
+        };
+
+    }
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["always", "never"]
+    }
+];

package/lib/rules/guard-for-in.js

@@ -1,32 +1,32 @@
-/**
- * @fileoverview Rule to flag for-in loops without if statements inside
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "ForInStatement": function(node) {
-
-            /*
-             * If the for-in statement has {}, then the real body is the body
-             * of the BlockStatement. Otherwise, just use body as provided.
-             */
-            var body = node.body.type === "BlockStatement" ? node.body.body[0] : node.body;
-
-            if (body && body.type !== "IfStatement") {
-                context.report(node, "The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag for-in loops without if statements inside
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "ForInStatement": function(node) {
+
+            /*
+             * If the for-in statement has {}, then the real body is the body
+             * of the BlockStatement. Otherwise, just use body as provided.
+             */
+            var body = node.body.type === "BlockStatement" ? node.body.body[0] : node.body;
+
+            if (body && body.type !== "IfStatement") {
+                context.report(node, "The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];