eslint 3.14.0 → 3.16.1

package/lib/config/config-file.js

@@ -23,7 +23,7 @@ const fs = require("fs"),
     stripBom = require("strip-bom"),
     stripComments = require("strip-json-comments"),
     stringify = require("json-stable-stringify"),
-    defaultOptions = require("../../conf/eslint.json"),
+    defaultOptions = require("../../conf/eslint-recommended"),
     requireUncached = require("require-uncached");
 
 const debug = require("debug")("eslint:config-file");
@@ -364,10 +364,10 @@ function applyExtends(config, filePath, relativeTo) {
         if (parentPath === "eslint:recommended") {
 
             /*
-             * Add an explicit substitution for eslint:recommended to conf/eslint.json
-             * this lets us use the eslint.json file as the recommended rules
+             * Add an explicit substitution for eslint:recommended to
+             * conf/eslint-recommended.js.
              */
-            parentPath = path.resolve(__dirname, "../../conf/eslint.json");
+            parentPath = path.resolve(__dirname, "../../conf/eslint-recommended.js");
         } else if (parentPath === "eslint:all") {
 
             /*
@@ -380,9 +380,9 @@ function applyExtends(config, filePath, relativeTo) {
              * If the `extends` path is relative, use the directory of the current configuration
              * file as the reference point. Otherwise, use as-is.
              */
-            parentPath = (!path.isAbsolute(parentPath) ?
-                path.join(relativeTo || path.dirname(filePath), parentPath) :
-                parentPath
+            parentPath = (!path.isAbsolute(parentPath)
+                ? path.join(relativeTo || path.dirname(filePath), parentPath)
+                : parentPath
             );
         }
 
@@ -390,6 +390,13 @@ function applyExtends(config, filePath, relativeTo) {
             debug(`Loading ${parentPath}`);
             return ConfigOps.merge(load(parentPath, false, relativeTo), previousValue);
         } catch (e) {
+            if (parentPath.indexOf("plugin:") === 0 || parentPath.indexOf("eslint:") === 0) {
+                e.message = `Failed to load config "${parentPath}" to extend from.`;
+                e.messageTemplate = "extend-config-missing";
+                e.messageData = {
+                    configName: parentPath
+                };
+            }
 
             /*
              * If the file referenced by `extends` failed to load, add the path
@@ -461,24 +468,24 @@ function normalizePackageName(name, prefix) {
 function resolve(filePath, relativeTo) {
     if (isFilePath(filePath)) {
         return { filePath: path.resolve(relativeTo || "", filePath) };
-    } else {
-        let normalizedPackageName;
-
-        if (filePath.indexOf("plugin:") === 0) {
-            const packagePath = filePath.substr(7, filePath.lastIndexOf("/") - 7);
-            const configName = filePath.substr(filePath.lastIndexOf("/") + 1, filePath.length - filePath.lastIndexOf("/") - 1);
-
-            normalizedPackageName = normalizePackageName(packagePath, "eslint-plugin");
-            debug(`Attempting to resolve ${normalizedPackageName}`);
-            filePath = resolver.resolve(normalizedPackageName, getLookupPath(relativeTo));
-            return { filePath, configName };
-        } else {
-            normalizedPackageName = normalizePackageName(filePath, "eslint-config");
-            debug(`Attempting to resolve ${normalizedPackageName}`);
-            filePath = resolver.resolve(normalizedPackageName, getLookupPath(relativeTo));
-            return { filePath };
-        }
     }
+    let normalizedPackageName;
+
+    if (filePath.indexOf("plugin:") === 0) {
+        const packagePath = filePath.substr(7, filePath.lastIndexOf("/") - 7);
+        const configName = filePath.substr(filePath.lastIndexOf("/") + 1, filePath.length - filePath.lastIndexOf("/") - 1);
+
+        normalizedPackageName = normalizePackageName(packagePath, "eslint-plugin");
+        debug(`Attempting to resolve ${normalizedPackageName}`);
+        filePath = resolver.resolve(normalizedPackageName, getLookupPath(relativeTo));
+        return { filePath, configName };
+    }
+    normalizedPackageName = normalizePackageName(filePath, "eslint-config");
+    debug(`Attempting to resolve ${normalizedPackageName}`);
+    filePath = resolver.resolve(normalizedPackageName, getLookupPath(relativeTo));
+    return { filePath };
+
+
 
 }
 

package/lib/config/config-initializer.js

@@ -17,7 +17,7 @@ const util = require("util"),
     ConfigOps = require("./config-ops"),
     getSourceCodeOfFiles = require("../util/source-code-util").getSourceCodeOfFiles,
     npmUtil = require("../util/npm-util"),
-    recConfig = require("../../conf/eslint.json"),
+    recConfig = require("../../conf/eslint-recommended"),
     log = require("../logging");
 
 const debug = require("debug")("eslint:config-initializer");

package/lib/config/config-validator.js

@@ -40,13 +40,13 @@ function getRuleOptionsSchema(id) {
                 minItems: 0,
                 maxItems: schema.length
             };
-        } else {
-            return {
-                type: "array",
-                minItems: 0,
-                maxItems: 0
-            };
         }
+        return {
+            type: "array",
+            minItems: 0,
+            maxItems: 0
+        };
+
     }
 
     // Given a full schema, leave it alone

package/lib/config.js

@@ -234,8 +234,9 @@ class Config {
     }
 
     /**
-     * Build a config object merging the base config (conf/eslint.json), the
-     * environments config (conf/environments.js) and eventually the user config.
+     * Build a config object merging the base config (conf/eslint-recommended),
+     * the environments config (conf/environments.js) and eventually the user
+     * config.
      * @param {string} filePath a file in whose directory we start looking for a local config
      * @returns {Object} config object
      */

package/lib/eslint.js

@@ -14,7 +14,7 @@ const assert = require("assert"),
     escope = require("escope"),
     levn = require("levn"),
     blankScriptAST = require("../conf/blank-script.json"),
-    DEFAULT_PARSER = require("../conf/eslint.json").parser,
+    DEFAULT_PARSER = require("../conf/eslint-recommended").parser,
     replacements = require("../conf/replacements.json"),
     CodePathAnalyzer = require("./code-path-analysis/code-path-analyzer"),
     ConfigOps = require("./config/config-ops"),
@@ -528,9 +528,9 @@ function createStubRule(message) {
 
     if (message) {
         return createRuleModule;
-    } else {
-        throw new Error("No message passed to stub rule");
     }
+    throw new Error("No message passed to stub rule");
+
 }
 
 /**
@@ -660,9 +660,9 @@ module.exports = (function() {
         try {
             if (typeof parser.parseForESLint === "function") {
                 return parser.parseForESLint(text, parserOptions);
-            } else {
-                return parser.parse(text, parserOptions);
             }
+            return parser.parse(text, parserOptions);
+
         } catch (ex) {
 
             // If the message includes a leading line number, strip it:
@@ -695,9 +695,9 @@ module.exports = (function() {
             return ruleConfig;
         } else if (Array.isArray(ruleConfig)) {
             return ruleConfig[0];
-        } else {
-            return 0;
         }
+        return 0;
+
     }
 
     /**
@@ -708,9 +708,9 @@ module.exports = (function() {
     function getRuleOptions(ruleConfig) {
         if (Array.isArray(ruleConfig)) {
             return ruleConfig.slice(1);
-        } else {
-            return [];
         }
+        return [];
+
     }
 
     // set unlimited listeners (see https://github.com/eslint/eslint/issues/524)
@@ -864,8 +864,8 @@ module.exports = (function() {
                         (parseResult && parseResult.services ? parseResult.services : {})
                     );
 
-                    const rule = ruleCreator.create ? ruleCreator.create(ruleContext) :
-                        ruleCreator(ruleContext);
+                    const rule = ruleCreator.create ? ruleCreator.create(ruleContext)
+                        : ruleCreator(ruleContext);
 
                     // add all the node types as listeners
                     Object.keys(rule).forEach(nodeType => {
@@ -939,9 +939,9 @@ module.exports = (function() {
 
             if (lineDiff === 0) {
                 return a.column - b.column;
-            } else {
-                return lineDiff;
             }
+            return lineDiff;
+
         });
 
         return messages;
@@ -1109,9 +1109,9 @@ module.exports = (function() {
                 if (scope) {
                     if (scope.type === "function-expression-name") {
                         return scope.childScopes[0];
-                    } else {
-                        return scope;
                     }
+                    return scope;
+
                 }
 
             }
@@ -1161,9 +1161,9 @@ module.exports = (function() {
     api.getFilename = function() {
         if (typeof currentFilename === "string") {
             return currentFilename;
-        } else {
-            return "<input>";
         }
+        return "<input>";
+
     };
 
     /**
@@ -1192,7 +1192,7 @@ module.exports = (function() {
      * @returns {Object} Object mapping rule IDs to their default configurations
      */
     api.defaults = function() {
-        return require("../conf/eslint.json");
+        return require("../conf/eslint-recommended");
     };
 
     /**

package/lib/formatters/checkstyle.js

@@ -19,9 +19,9 @@ const xmlEscape = require("../util/xml-escape");
 function getMessageType(message) {
     if (message.fatal || message.severity === 2) {
         return "error";
-    } else {
-        return "warning";
     }
+    return "warning";
+
 }
 
 //------------------------------------------------------------------------------

package/lib/formatters/compact.js

@@ -17,9 +17,9 @@
 function getMessageType(message) {
     if (message.fatal || message.severity === 2) {
         return "Error";
-    } else {
-        return "Warning";
     }
+    return "Warning";
+
 }
 
 

package/lib/formatters/junit.js

@@ -19,9 +19,9 @@ const xmlEscape = require("../util/xml-escape");
 function getMessageType(message) {
     if (message.fatal || message.severity === 2) {
         return "Error";
-    } else {
-        return "Warning";
     }
+    return "Warning";
+
 }
 
 //------------------------------------------------------------------------------

package/lib/formatters/tap.js

@@ -18,9 +18,9 @@ const yaml = require("js-yaml");
 function getMessageType(message) {
     if (message.fatal || message.severity === 2) {
         return "error";
-    } else {
-        return "warning";
     }
+    return "warning";
+
 }
 
 /**

package/lib/formatters/unix.js

@@ -16,9 +16,9 @@
 function getMessageType(message) {
     if (message.fatal || message.severity === 2) {
         return "Error";
-    } else {
-        return "Warning";
     }
+    return "Warning";
+
 }
 
 

package/lib/formatters/visualstudio.js

@@ -18,9 +18,9 @@
 function getMessageType(message) {
     if (message.fatal || message.severity === 2) {
         return "error";
-    } else {
-        return "warning";
     }
+    return "warning";
+
 }
 
 

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

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -136,10 +142,7 @@ module.exports = {
                         loc: arrowBody.loc.start,
                         message: "Expected block statement surrounding arrow body.",
                         fix(fixer) {
-                            const lastTokenBeforeBody = sourceCode.getTokensBetween(sourceCode.getFirstToken(node), arrowBody)
-                                .reverse()
-                                .find(token => token.value !== "(");
-
+                            const lastTokenBeforeBody = sourceCode.getLastTokenBetween(sourceCode.getFirstToken(node), arrowBody, astUtils.isNotOpeningParenToken);
                             const firstBodyToken = sourceCode.getTokenAfter(lastTokenBeforeBody);
 
                             return fixer.replaceTextRange(

package/lib/rules/arrow-spacing.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -51,12 +57,7 @@ module.exports = {
          * @returns {Object} Tokens of arrow and before/after arrow.
          */
         function getTokens(node) {
-            let arrow = sourceCode.getTokenBefore(node.body);
-
-            // skip '(' tokens.
-            while (arrow.value !== "=>") {
-                arrow = sourceCode.getTokenBefore(arrow);
-            }
+            const arrow = sourceCode.getTokenBefore(node.body, astUtils.isArrowToken);
 
             return {
                 before: sourceCode.getTokenBefore(arrow),

package/lib/rules/block-spacing.js

@@ -74,8 +74,8 @@ module.exports = {
             // Gets braces and the first/last token of content.
             const openBrace = getOpenBrace(node);
             const closeBrace = sourceCode.getLastToken(node);
-            const firstToken = sourceCode.getTokenOrCommentAfter(openBrace);
-            const lastToken = sourceCode.getTokenOrCommentBefore(closeBrace);
+            const firstToken = sourceCode.getTokenAfter(openBrace, { includeComments: true });
+            const lastToken = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
 
             // Skip if the node is invalid or empty.
             if (openBrace.type !== "Punctuator" ||

package/lib/rules/brace-style.js

@@ -62,7 +62,7 @@ module.exports = {
         function removeNewlineBetween(firstToken, secondToken) {
             const textRange = [firstToken.range[1], secondToken.range[0]];
             const textBetween = sourceCode.text.slice(textRange[0], textRange[1]);
-            const NEWLINE_REGEX = /\r\n|\r|\n|\u2028|\u2029/g;
+            const NEWLINE_REGEX = astUtils.createGlobalLinebreakMatcher();
 
             // Don't do a fix if there is a comment between the tokens
             return fixer => fixer.replaceTextRange(textRange, textBetween.trim() ? null : textBetween.replace(NEWLINE_REGEX, ""));
@@ -78,7 +78,6 @@ module.exports = {
             const tokenBeforeOpeningCurly = sourceCode.getTokenBefore(openingCurly);
             const tokenAfterOpeningCurly = sourceCode.getTokenAfter(openingCurly);
             const tokenBeforeClosingCurly = sourceCode.getTokenBefore(closingCurly);
-            const tokenAfterClosingCurly = sourceCode.getTokenAfter(closingCurly);
             const singleLineException = params.allowSingleLine && astUtils.isTokenOnSameLine(openingCurly, closingCurly);
 
             if (style !== "allman" && !astUtils.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly)) {
@@ -112,23 +111,30 @@ module.exports = {
                     fix: fixer => fixer.insertTextBefore(closingCurly, "\n")
                 });
             }
+        }
 
-            if (tokenAfterClosingCurly && tokenAfterClosingCurly.type === "Keyword" && new Set(["else", "catch", "finally"]).has(tokenAfterClosingCurly.value)) {
-                if (style === "1tbs" && !astUtils.isTokenOnSameLine(closingCurly, tokenAfterClosingCurly)) {
-                    context.report({
-                        node: closingCurly,
-                        message: CLOSE_MESSAGE,
-                        fix: removeNewlineBetween(closingCurly, tokenAfterClosingCurly)
-                    });
-                }
+        /**
+        * Validates the location of a token that appears before a keyword (e.g. a newline before `else`)
+        * @param {Token} curlyToken The closing curly token. This is assumed to precede a keyword token (such as `else` or `finally`).
+        * @returns {void}
+        */
+        function validateCurlyBeforeKeyword(curlyToken) {
+            const keywordToken = sourceCode.getTokenAfter(curlyToken);
 
-                if (style !== "1tbs" && astUtils.isTokenOnSameLine(closingCurly, tokenAfterClosingCurly)) {
-                    context.report({
-                        node: closingCurly,
-                        message: CLOSE_MESSAGE_STROUSTRUP_ALLMAN,
-                        fix: fixer => fixer.insertTextAfter(closingCurly, "\n")
-                    });
-                }
+            if (style === "1tbs" && !astUtils.isTokenOnSameLine(curlyToken, keywordToken)) {
+                context.report({
+                    node: curlyToken,
+                    message: CLOSE_MESSAGE,
+                    fix: removeNewlineBetween(curlyToken, keywordToken)
+                });
+            }
+
+            if (style !== "1tbs" && astUtils.isTokenOnSameLine(curlyToken, keywordToken)) {
+                context.report({
+                    node: curlyToken,
+                    message: CLOSE_MESSAGE_STROUSTRUP_ALLMAN,
+                    fix: fixer => fixer.insertTextAfter(curlyToken, "\n")
+                });
             }
         }
 
@@ -138,11 +144,7 @@ module.exports = {
 
         return {
             BlockStatement(node) {
-                if (
-                    node.parent.type !== "BlockStatement" &&
-                    node.parent.type !== "SwitchCase" &&
-                    node.parent.type !== "Program"
-                ) {
+                if (!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)) {
                     validateCurlyPair(sourceCode.getFirstToken(node), sourceCode.getLastToken(node));
                 }
             },
@@ -154,6 +156,24 @@ module.exports = {
                 const openingCurly = sourceCode.getTokenBefore(node.cases.length ? node.cases[0] : closingCurly);
 
                 validateCurlyPair(openingCurly, closingCurly);
+            },
+            IfStatement(node) {
+                if (node.consequent.type === "BlockStatement" && node.alternate) {
+
+                    // Handle the keyword after the `if` block (before `else`)
+                    validateCurlyBeforeKeyword(sourceCode.getLastToken(node.consequent));
+                }
+            },
+            TryStatement(node) {
+
+                // Handle the keyword after the `try` block (before `catch` or `finally`)
+                validateCurlyBeforeKeyword(sourceCode.getLastToken(node.block));
+
+                if (node.handler && node.finalizer) {
+
+                    // Handle the keyword after the `catch` block (before `finally`)
+                    validateCurlyBeforeKeyword(sourceCode.getLastToken(node.handler.body));
+                }
             }
         };
     }

package/lib/rules/capitalized-comments.js

@@ -163,8 +163,8 @@ module.exports = {
          * otherwise.
          */
         function isInlineComment(comment) {
-            const previousToken = sourceCode.getTokenOrCommentBefore(comment),
-                nextToken = sourceCode.getTokenOrCommentAfter(comment);
+            const previousToken = sourceCode.getTokenBefore(comment, { includeComments: true }),
+                nextToken = sourceCode.getTokenAfter(comment, { includeComments: true });
 
             return Boolean(
                 previousToken &&
@@ -181,7 +181,7 @@ module.exports = {
          * @returns {boolean} True if the comment follows a valid comment.
          */
         function isConsecutiveComment(comment) {
-            const previousTokenOrComment = sourceCode.getTokenOrCommentBefore(comment);
+            const previousTokenOrComment = sourceCode.getTokenBefore(comment, { includeComments: true });
 
             return Boolean(
                 previousTokenOrComment &&
@@ -264,9 +264,9 @@ module.exports = {
                 commentValid = isCommentValid(comment, options);
 
             if (!commentValid) {
-                const message = capitalize === "always" ?
-                    ALWAYS_MESSAGE :
-                    NEVER_MESSAGE;
+                const message = capitalize === "always"
+                    ? ALWAYS_MESSAGE
+                    : NEVER_MESSAGE;
 
                 context.report({
                     node: null,         // Intentionally using loc instead

package/lib/rules/comma-spacing.js

@@ -78,27 +78,27 @@ module.exports = {
                     if (options[dir]) {
                         if (dir === "before") {
                             return fixer.insertTextBefore(node, " ");
-                        } else {
-                            return fixer.insertTextAfter(node, " ");
                         }
-                    } else {
-                        let start, end;
-                        const newText = "";
+                        return fixer.insertTextAfter(node, " ");
 
-                        if (dir === "before") {
-                            start = otherNode.range[1];
-                            end = node.range[0];
-                        } else {
-                            start = node.range[1];
-                            end = otherNode.range[0];
-                        }
+                    }
+                    let start, end;
+                    const newText = "";
 
-                        return fixer.replaceTextRange([start, end], newText);
+                    if (dir === "before") {
+                        start = otherNode.range[1];
+                        end = node.range[0];
+                    } else {
+                        start = node.range[1];
+                        end = otherNode.range[0];
                     }
+
+                    return fixer.replaceTextRange([start, end], newText);
+
                 },
-                message: options[dir] ?
-                  "A space is required {{dir}} ','." :
-                  "There should be no space {{dir}} ','.",
+                message: options[dir]
+                  ? "A space is required {{dir}} ','."
+                  : "There should be no space {{dir}} ','.",
                 data: {
                     dir
                 }

package/lib/rules/consistent-return.js

@@ -104,7 +104,7 @@ module.exports = {
             } else if (node.type === "ArrowFunctionExpression") {
 
                 // `=>` token
-                loc = context.getSourceCode().getTokenBefore(node.body).loc.start;
+                loc = context.getSourceCode().getTokenBefore(node.body, astUtils.isArrowToken).loc.start;
                 type = "function";
             } else if (
                 node.parent.type === "MethodDefinition" ||

package/lib/rules/constructor-super.js

@@ -209,9 +209,9 @@ module.exports = {
 
                 if (!calledInEveryPaths) {
                     context.report({
-                        message: calledInSomePaths ?
-                            "Lacked a call of 'super()' in some code paths." :
-                            "Expected to call 'super()'.",
+                        message: calledInSomePaths
+                            ? "Lacked a call of 'super()' in some code paths."
+                            : "Expected to call 'super()'.",
                         node: node.parent
                     });
                 }

package/lib/rules/curly.js

@@ -94,19 +94,23 @@ module.exports = {
             return first.loc.start.line === last.loc.end.line;
         }
 
+        /**
+         * Checks if the given token is an `else` token or not.
+         *
+         * @param {Token} token - The token to check.
+         * @returns {boolean} `true` if the token is an `else` token.
+         */
+        function isElseKeywordToken(token) {
+            return token.value === "else" && token.type === "Keyword";
+        }
+
         /**
          * Gets the `else` keyword token of a given `IfStatement` node.
          * @param {ASTNode} node - A `IfStatement` node to get.
          * @returns {Token} The `else` keyword token.
          */
         function getElseKeyword(node) {
-            let token = sourceCode.getTokenAfter(node.consequent);
-
-            while (token.type !== "Keyword" || token.value !== "else") {
-                token = sourceCode.getTokenAfter(token);
-            }
-
-            return token;
+            return node.alternate && sourceCode.getFirstTokenBetween(node.consequent, node.alternate, isElseKeywordToken);
         }
 
         /**

package/lib/rules/default-case.js

@@ -31,9 +31,9 @@ module.exports = {
 
     create(context) {
         const options = context.options[0] || {};
-        const commentPattern = options.commentPattern ?
-            new RegExp(options.commentPattern) :
-            DEFAULT_COMMENT_PATTERN;
+        const commentPattern = options.commentPattern
+            ? new RegExp(options.commentPattern)
+            : DEFAULT_COMMENT_PATTERN;
 
         const sourceCode = context.getSourceCode();