eslint 2.11.0 → 2.13.1

package/lib/rules/arrow-body-style.js

@@ -16,16 +16,45 @@ module.exports = {
             recommended: false
         },
 
-        schema: [
-            {
-                enum: ["always", "as-needed"]
-            }
-        ]
+        schema: {
+            anyOf: [
+                {
+                    type: "array",
+                    items: [
+                        {
+                            enum: ["always", "never"]
+                        }
+                    ],
+                    minItems: 0,
+                    maxItems: 1
+                },
+                {
+                    type: "array",
+                    items: [
+                        {
+                            enum: ["as-needed"]
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                requireReturnForObjectLiteral: {type: "boolean"}
+                            },
+                            additionalProperties: false
+                        }
+                    ],
+                    minItems: 0,
+                    maxItems: 2
+                }
+            ]
+        }
     },
 
     create: function(context) {
-        var always = context.options[0] === "always";
-        var asNeeded = !context.options[0] || context.options[0] === "as-needed";
+        var options = context.options;
+        var always = options[0] === "always";
+        var asNeeded = !options[0] || options[0] === "as-needed";
+        var never = options[0] === "never";
+        var requireReturnForObjectLiteral = options[1] && options[1].requireReturnForObjectLiteral;
 
         /**
          * Determines whether a arrow function body needs braces
@@ -36,21 +65,34 @@ module.exports = {
             var arrowBody = node.body;
 
             if (arrowBody.type === "BlockStatement") {
-                var blockBody = arrowBody.body;
-
-                if (blockBody.length !== 1) {
-                    return;
-                }
-
-                if (asNeeded && blockBody[0].type === "ReturnStatement") {
+                if (never) {
                     context.report({
                         node: node,
                         loc: arrowBody.loc.start,
                         message: "Unexpected block statement surrounding arrow body."
                     });
+                } else {
+                    var blockBody = arrowBody.body;
+
+                    if (blockBody.length !== 1) {
+                        return;
+                    }
+
+                    if (asNeeded && requireReturnForObjectLiteral && blockBody[0].type === "ReturnStatement" &&
+                        blockBody[0].argument.type === "ObjectExpression") {
+                        return;
+                    }
+
+                    if (asNeeded && blockBody[0].type === "ReturnStatement") {
+                        context.report({
+                            node: node,
+                            loc: arrowBody.loc.start,
+                            message: "Unexpected block statement surrounding arrow body."
+                        });
+                    }
                 }
             } else {
-                if (always) {
+                if (always || (asNeeded && requireReturnForObjectLiteral && arrowBody.type === "ObjectExpression")) {
                     context.report({
                         node: node,
                         loc: arrowBody.loc.start,

package/lib/rules/callback-return.js

@@ -24,7 +24,8 @@ module.exports = {
 
     create: function(context) {
 
-        var callbacks = context.options[0] || ["callback", "cb", "next"];
+        var callbacks = context.options[0] || ["callback", "cb", "next"],
+            sourceCode = context.getSourceCode();
 
         //--------------------------------------------------------------------------
         // Helpers
@@ -46,13 +47,34 @@ module.exports = {
             return node.parent;
         }
 
+        /**
+         * Check to see if a node contains only identifers
+         * @param {ASTNode} node The node to check
+         * @returns {Boolean} Whether or not the node contains only identifers
+         */
+        function containsOnlyIdentifiers(node) {
+            if (node.type === "Identifier") {
+                return true;
+            }
+
+            if (node.type === "MemberExpression") {
+                if (node.object.type === "Identifier") {
+                    return true;
+                } else if (node.object.type === "MemberExpression") {
+                    return containsOnlyIdentifiers(node.object);
+                }
+            }
+
+            return false;
+        }
+
         /**
          * Check to see if a CallExpression is in our callback list.
          * @param {ASTNode} node The node to check against our callback names list.
          * @returns {Boolean} Whether or not this function matches our callback name.
          */
         function isCallback(node) {
-            return node.callee.type === "Identifier" && callbacks.indexOf(node.callee.name) > -1;
+            return containsOnlyIdentifiers(node.callee) && callbacks.indexOf(sourceCode.getText(node.callee)) > -1;
         }
 
         /**
@@ -90,7 +112,7 @@ module.exports = {
         return {
             CallExpression: function(node) {
 
-                // if we"re not a callback we can return
+                // if we're not a callback we can return
                 if (!isCallback(node)) {
                     return;
                 }

package/lib/rules/default-case.js

@@ -13,7 +13,7 @@ var DEFAULT_COMMENT_PATTERN = /^no default$/;
 module.exports = {
     meta: {
         docs: {
-            description: "require `default` cases in <code>switch</code> statements",
+            description: "require `default` cases in `switch` statements",
             category: "Best Practices",
             recommended: false
         },

package/lib/rules/eqeqeq.js

@@ -19,7 +19,7 @@ module.exports = {
 
         schema: [
             {
-                enum: ["smart", "allow-null"]
+                enum: ["always", "smart", "allow-null"]
             }
         ]
     },

package/lib/rules/func-names.js

@@ -12,15 +12,20 @@
 module.exports = {
     meta: {
         docs: {
-            description: "enforce named `function` expressions",
+            description: "require or disallow named `function` expressions",
             category: "Stylistic Issues",
             recommended: false
         },
 
-        schema: []
+        schema: [
+            {
+                enum: ["always", "never"]
+            }
+        ]
     },
 
     create: function(context) {
+        var never = context.options[0] === "never";
 
         /**
          * Determines whether the current FunctionExpression node is a get, set, or
@@ -44,8 +49,14 @@ module.exports = {
 
                 var name = node.id && node.id.name;
 
-                if (!name && !isObjectOrClassMethod()) {
-                    context.report(node, "Missing function expression name.");
+                if (never) {
+                    if (name) {
+                        context.report(node, "Unexpected function expression name.");
+                    }
+                } else {
+                    if (!name && !isObjectOrClassMethod()) {
+                        context.report(node, "Missing function expression name.");
+                    }
                 }
             }
         };

package/lib/rules/max-len.js

@@ -157,10 +157,11 @@ module.exports = {
          */
         function isFullLineComment(line, lineNumber, comment) {
             var start = comment.loc.start,
-                end = comment.loc.end;
+                end = comment.loc.end,
+                isFirstTokenOnLine = !line.slice(0, comment.loc.start.column).trim();
 
             return comment &&
-                (start.line < lineNumber || (start.line === lineNumber && start.column === 0)) &&
+                (start.line < lineNumber || (start.line === lineNumber && isFirstTokenOnLine)) &&
                 (end.line > lineNumber || end.column === line.length);
         }
 

package/lib/rules/max-lines.js

@@ -0,0 +1,148 @@
+/**
+ * @fileoverview enforce a maximum file length
+ * @author Alberto Rodríguez
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var lodash = require("lodash");
+var astUtils = require("../ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "enforce a maximum number of lines per file",
+            category: "Stylistic Issues",
+            recommended: false
+        },
+
+        schema: [
+            {
+                oneOf: [
+                    {
+                        type: "integer",
+                        minimum: 0
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            max: {
+                                type: "integer",
+                                minimum: 0
+                            },
+                            skipComments: {
+                                type: "boolean"
+                            },
+                            skipBlankLines: {
+                                type: "boolean"
+                            }
+                        },
+                        additionalProperties: false
+                    }
+                ]
+            }
+        ]
+    },
+
+    create: function(context) {
+        var option = context.options[0],
+            max = 300;
+
+        if (typeof option === "object" && option.hasOwnProperty("max") && typeof option.max === "number") {
+            max = option.max;
+        }
+
+        if (typeof option === "number") {
+            max = option;
+        }
+
+        var skipComments = option && option.skipComments;
+        var skipBlankLines = option && option.skipBlankLines;
+
+        var sourceCode = context.getSourceCode();
+
+        /**
+         * Returns whether or not a token is a comment node type
+         * @param {Token} token The token to check
+         * @returns {boolean} True if the token is a comment node
+         */
+        function isCommentNodeType(token) {
+            return token && (token.type === "Block" || token.type === "Line");
+        }
+
+        /**
+         * Returns the line numbers of a comment that don't have any code on the same line
+         * @param {Node} comment The comment node to check
+         * @returns {int[]} The line numbers
+         */
+        function getLinesWithoutCode(comment) {
+            var start = comment.loc.start.line;
+            var end = comment.loc.end.line;
+
+            var token;
+
+            token = comment;
+            do {
+                token = sourceCode.getTokenOrCommentBefore(token);
+            } while (isCommentNodeType(token));
+
+            if (token && astUtils.isTokenOnSameLine(token, comment)) {
+                start += 1;
+            }
+
+            token = comment;
+            do {
+                token = sourceCode.getTokenOrCommentAfter(token);
+            } while (isCommentNodeType(token));
+
+            if (token && astUtils.isTokenOnSameLine(comment, token)) {
+                end -= 1;
+            }
+
+            if (start <= end) {
+                return lodash.range(start, end + 1);
+            }
+            return [];
+        }
+
+        return {
+            "Program:exit": function() {
+                var lines = sourceCode.lines.map(function(text, i) {
+                    return { lineNumber: i + 1, text: text };
+                });
+
+                if (skipBlankLines) {
+                    lines = lines.filter(function(l) {
+                        return l.text.trim() !== "";
+                    });
+                }
+
+                if (skipComments) {
+                    var comments = sourceCode.getAllComments();
+
+                    var commentLines = lodash.flatten(comments.map(function(comment) {
+                        return getLinesWithoutCode(comment);
+                    }));
+
+                    lines = lines.filter(function(l) {
+                        return !lodash.includes(commentLines, l.lineNumber);
+                    });
+                }
+
+                if (lines.length > max) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        message: "File must be at most " + max + " lines long"
+                    });
+                }
+            }
+        };
+    }
+};

package/lib/rules/max-statements-per-line.js

@@ -43,7 +43,7 @@ module.exports = {
         // Helpers
         //--------------------------------------------------------------------------
 
-        var SINGLE_CHILD_ALLOWED = /^(?:DoWhile|For|ForIn|ForOf|If|Labeled|While)Statement$/;
+        var SINGLE_CHILD_ALLOWED = /^(?:(?:DoWhile|For|ForIn|ForOf|If|Labeled|While)Statement|Export(?:Default|Named)Declaration)$/;
 
         /**
          * Gets the actual last token of a given node.

package/lib/rules/newline-per-chained-call.js

@@ -38,6 +38,21 @@ module.exports = {
 
         var sourceCode = context.getSourceCode();
 
+        /**
+         * Gets the property text of a given MemberExpression node.
+         * If the text is multiline, this returns only the first line.
+         *
+         * @param {ASTNode} node - A MemberExpression node to get.
+         * @returns {string} The property text of the node.
+         */
+        function getPropertyText(node) {
+            var prefix = node.computed ? "[" : ".";
+            var lines = sourceCode.getText(node.property).split(/\r\n|\r|\n/g);
+            var suffix = node.computed && lines.length === 1 ? "]" : "";
+
+            return prefix + lines[0] + suffix;
+        }
+
         return {
             "CallExpression:exit": function(node) {
                 if (!node.callee || node.callee.type !== "MemberExpression") {
@@ -57,7 +72,7 @@ module.exports = {
                     context.report(
                         callee.property,
                         callee.property.loc.start,
-                        "Expected line break after `" + sourceCode.getText(callee.object).replace(/\r\n|\r|\n/g, "\\n") + "`."
+                        "Expected line break before `" + getPropertyText(callee) + "`."
                     );
                 }
             }

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

@@ -57,6 +57,7 @@ module.exports = {
         var sourceCode = context.getSourceCode();
 
         var isParenthesised = astUtils.isParenthesised.bind(astUtils, sourceCode);
+        var precedence = astUtils.getPrecedence;
         var ALL_NODES = context.options[0] !== "functions";
         var EXCEPT_COND_ASSIGN = ALL_NODES && context.options[1] && context.options[1].conditionalAssign === false;
         var NESTED_BINARY = ALL_NODES && context.options[1] && context.options[1].nestedBinaryExpressions === false;
@@ -255,98 +256,6 @@ module.exports = {
             throw new Error("unreachable");
         }
 
-        /**
-         * Get the precedence level based on the node type
-         * @param {ASTNode} node node to evaluate
-         * @returns {int} precedence level
-         * @private
-         */
-        function precedence(node) {
-
-            switch (node.type) {
-                case "SequenceExpression":
-                    return 0;
-
-                case "AssignmentExpression":
-                case "ArrowFunctionExpression":
-                case "YieldExpression":
-                    return 1;
-
-                case "ConditionalExpression":
-                    return 3;
-
-                case "LogicalExpression":
-                    switch (node.operator) {
-                        case "||":
-                            return 4;
-                        case "&&":
-                            return 5;
-
-                        // no default
-                    }
-
-                    /* falls through */
-
-                case "BinaryExpression":
-
-                    switch (node.operator) {
-                        case "|":
-                            return 6;
-                        case "^":
-                            return 7;
-                        case "&":
-                            return 8;
-                        case "==":
-                        case "!=":
-                        case "===":
-                        case "!==":
-                            return 9;
-                        case "<":
-                        case "<=":
-                        case ">":
-                        case ">=":
-                        case "in":
-                        case "instanceof":
-                            return 10;
-                        case "<<":
-                        case ">>":
-                        case ">>>":
-                            return 11;
-                        case "+":
-                        case "-":
-                            return 12;
-                        case "*":
-                        case "/":
-                        case "%":
-                            return 13;
-
-                        // no default
-                    }
-
-                    /* falls through */
-
-                case "UnaryExpression":
-                    return 14;
-
-                case "UpdateExpression":
-                    return 15;
-
-                case "CallExpression":
-
-                    // IIFE is allowed to have parens in any position (#655)
-                    if (node.callee.type === "FunctionExpression") {
-                        return -1;
-                    }
-                    return 16;
-
-                case "NewExpression":
-                    return 17;
-
-                // no default
-            }
-            return 18;
-        }
-
         /**
          * Report the node
          * @param {ASTNode} node node to evaluate

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

@@ -66,7 +66,16 @@ module.exports = {
              */
             EmptyStatement: function(node) {
                 var parent = node.parent,
-                    allowedParentTypes = ["ForStatement", "ForInStatement", "ForOfStatement", "WhileStatement", "DoWhileStatement"];
+                    allowedParentTypes = [
+                        "ForStatement",
+                        "ForInStatement",
+                        "ForOfStatement",
+                        "WhileStatement",
+                        "DoWhileStatement",
+                        "IfStatement",
+                        "LabeledStatement",
+                        "WithStatement"
+                    ];
 
                 if (allowedParentTypes.indexOf(parent.type) === -1) {
                     report(node);