eslint 4.18.0 → 4.19.1

package/lib/rules/one-var.js

@@ -22,7 +22,7 @@ module.exports = {
             {
                 oneOf: [
                     {
-                        enum: ["always", "never"]
+                        enum: ["always", "never", "consecutive"]
                     },
                     {
                         type: "object",
@@ -31,13 +31,13 @@ module.exports = {
                                 type: "boolean"
                             },
                             var: {
-                                enum: ["always", "never"]
+                                enum: ["always", "never", "consecutive"]
                             },
                             let: {
-                                enum: ["always", "never"]
+                                enum: ["always", "never", "consecutive"]
                             },
                             const: {
-                                enum: ["always", "never"]
+                                enum: ["always", "never", "consecutive"]
                             }
                         },
                         additionalProperties: false
@@ -46,10 +46,10 @@ module.exports = {
                         type: "object",
                         properties: {
                             initialized: {
-                                enum: ["always", "never"]
+                                enum: ["always", "never", "consecutive"]
                             },
                             uninitialized: {
-                                enum: ["always", "never"]
+                                enum: ["always", "never", "consecutive"]
                             }
                         },
                         additionalProperties: false
@@ -60,10 +60,9 @@ module.exports = {
     },
 
     create(context) {
-
-        const MODE_ALWAYS = "always",
-            MODE_NEVER = "never";
-
+        const MODE_ALWAYS = "always";
+        const MODE_NEVER = "never";
+        const MODE_CONSECUTIVE = "consecutive";
         const mode = context.options[0] || MODE_ALWAYS;
 
         const options = {};
@@ -273,119 +272,163 @@ module.exports = {
             return true;
         }
 
+        /**
+         * Checks a given VariableDeclaration node for errors.
+         * @param {ASTNode} node The VariableDeclaration node to check
+         * @returns {void}
+         * @private
+         */
+        function checkVariableDeclaration(node) {
+            const parent = node.parent;
+            const type = node.kind;
 
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
+            if (!options[type]) {
+                return;
+            }
 
-        return {
-            Program: startFunction,
-            FunctionDeclaration: startFunction,
-            FunctionExpression: startFunction,
-            ArrowFunctionExpression: startFunction,
-            BlockStatement: startBlock,
-            ForStatement: startBlock,
-            ForInStatement: startBlock,
-            ForOfStatement: startBlock,
-            SwitchStatement: startBlock,
+            const declarations = node.declarations;
+            const declarationCounts = countDeclarations(declarations);
+            const mixedRequires = declarations.some(isRequire) && !declarations.every(isRequire);
+
+            if (options[type].initialized === MODE_ALWAYS) {
+                if (options.separateRequires && mixedRequires) {
+                    context.report({
+                        node,
+                        message: "Split requires to be separated into a single block."
+                    });
+                }
+            }
 
-            VariableDeclaration(node) {
-                const parent = node.parent;
-                const type = node.kind;
+            // consecutive
+            const nodeIndex = (parent.body && parent.body.length > 0 && parent.body.indexOf(node)) || 0;
 
-                if (!options[type]) {
-                    return;
-                }
+            if (nodeIndex > 0) {
+                const previousNode = parent.body[nodeIndex - 1];
+                const isPreviousNodeDeclaration = previousNode.type === "VariableDeclaration";
 
-                const declarations = node.declarations;
-                const declarationCounts = countDeclarations(declarations);
-                const mixedRequires = declarations.some(isRequire) && !declarations.every(isRequire);
+                if (isPreviousNodeDeclaration && previousNode.kind === type) {
+                    const previousDeclCounts = countDeclarations(previousNode.declarations);
 
-                if (options[type].initialized === MODE_ALWAYS) {
-                    if (options.separateRequires && mixedRequires) {
+                    if (options[type].initialized === MODE_CONSECUTIVE && options[type].uninitialized === MODE_CONSECUTIVE) {
+                        context.report({
+                            node,
+                            message: "Combine this with the previous '{{type}}' statement.",
+                            data: {
+                                type
+                            }
+                        });
+                    } else if (options[type].initialized === MODE_CONSECUTIVE && declarationCounts.initialized > 0 && previousDeclCounts.initialized > 0) {
                         context.report({
                             node,
-                            message: "Split requires to be separated into a single block."
+                            message: "Combine this with the previous '{{type}}' statement with initialized variables.",
+                            data: {
+                                type
+                            }
+                        });
+                    } else if (options[type].uninitialized === MODE_CONSECUTIVE &&
+                            declarationCounts.uninitialized > 0 &&
+                            previousDeclCounts.uninitialized > 0) {
+                        context.report({
+                            node,
+                            message: "Combine this with the previous '{{type}}' statement with uninitialized variables.",
+                            data: {
+                                type
+                            }
                         });
                     }
                 }
+            }
 
-                // always
-                if (!hasOnlyOneStatement(type, declarations)) {
-                    if (options[type].initialized === MODE_ALWAYS && options[type].uninitialized === MODE_ALWAYS) {
+            // always
+            if (!hasOnlyOneStatement(type, declarations)) {
+                if (options[type].initialized === MODE_ALWAYS && options[type].uninitialized === MODE_ALWAYS) {
+                    context.report({
+                        node,
+                        message: "Combine this with the previous '{{type}}' statement.",
+                        data: {
+                            type
+                        }
+                    });
+                } else {
+                    if (options[type].initialized === MODE_ALWAYS && declarationCounts.initialized > 0) {
                         context.report({
                             node,
-                            message: "Combine this with the previous '{{type}}' statement.",
+                            message: "Combine this with the previous '{{type}}' statement with initialized variables.",
                             data: {
                                 type
                             }
                         });
-                    } else {
-                        if (options[type].initialized === MODE_ALWAYS) {
-                            context.report({
-                                node,
-                                message: "Combine this with the previous '{{type}}' statement with initialized variables.",
-                                data: {
-                                    type
-                                }
-                            });
+                    }
+                    if (options[type].uninitialized === MODE_ALWAYS && declarationCounts.uninitialized > 0) {
+                        if (node.parent.left === node && (node.parent.type === "ForInStatement" || node.parent.type === "ForOfStatement")) {
+                            return;
                         }
-                        if (options[type].uninitialized === MODE_ALWAYS) {
-                            if (node.parent.left === node && (node.parent.type === "ForInStatement" || node.parent.type === "ForOfStatement")) {
-                                return;
+                        context.report({
+                            node,
+                            message: "Combine this with the previous '{{type}}' statement with uninitialized variables.",
+                            data: {
+                                type
                             }
-                            context.report({
-                                node,
-                                message: "Combine this with the previous '{{type}}' statement with uninitialized variables.",
-                                data: {
-                                    type
-                                }
-                            });
-                        }
+                        });
                     }
                 }
+            }
 
-                // never
-                if (parent.type !== "ForStatement" || parent.init !== node) {
-                    const totalDeclarations = declarationCounts.uninitialized + declarationCounts.initialized;
-
-                    if (totalDeclarations > 1) {
-
-                        if (options[type].initialized === MODE_NEVER && options[type].uninitialized === MODE_NEVER) {
-
-                            // both initialized and uninitialized
-                            context.report({
-                                node,
-                                message: "Split '{{type}}' declarations into multiple statements.",
-                                data: {
-                                    type
-                                }
-                            });
-                        } else if (options[type].initialized === MODE_NEVER && declarationCounts.initialized > 0) {
-
-                            // initialized
-                            context.report({
-                                node,
-                                message: "Split initialized '{{type}}' declarations into multiple statements.",
-                                data: {
-                                    type
-                                }
-                            });
-                        } else if (options[type].uninitialized === MODE_NEVER && declarationCounts.uninitialized > 0) {
-
-                            // uninitialized
-                            context.report({
-                                node,
-                                message: "Split uninitialized '{{type}}' declarations into multiple statements.",
-                                data: {
-                                    type
-                                }
-                            });
-                        }
+            // never
+            if (parent.type !== "ForStatement" || parent.init !== node) {
+                const totalDeclarations = declarationCounts.uninitialized + declarationCounts.initialized;
+
+                if (totalDeclarations > 1) {
+                    if (options[type].initialized === MODE_NEVER && options[type].uninitialized === MODE_NEVER) {
+
+                        // both initialized and uninitialized
+                        context.report({
+                            node,
+                            message: "Split '{{type}}' declarations into multiple statements.",
+                            data: {
+                                type
+                            }
+                        });
+                    } else if (options[type].initialized === MODE_NEVER && declarationCounts.initialized > 0) {
+
+                        // initialized
+                        context.report({
+                            node,
+                            message: "Split initialized '{{type}}' declarations into multiple statements.",
+                            data: {
+                                type
+                            }
+                        });
+                    } else if (options[type].uninitialized === MODE_NEVER && declarationCounts.uninitialized > 0) {
+
+                        // uninitialized
+                        context.report({
+                            node,
+                            message: "Split uninitialized '{{type}}' declarations into multiple statements.",
+                            data: {
+                                type
+                            }
+                        });
                     }
                 }
-            },
+            }
+        }
+
+        //--------------------------------------------------------------------------
+        // Public API
+        //--------------------------------------------------------------------------
 
+        return {
+            Program: startFunction,
+            FunctionDeclaration: startFunction,
+            FunctionExpression: startFunction,
+            ArrowFunctionExpression: startFunction,
+            BlockStatement: startBlock,
+            ForStatement: startBlock,
+            ForInStatement: startBlock,
+            ForOfStatement: startBlock,
+            SwitchStatement: startBlock,
+            VariableDeclaration: checkVariableDeclaration,
             "ForStatement:exit": endBlock,
             "ForOfStatement:exit": endBlock,
             "ForInStatement:exit": endBlock,

package/lib/rules/padding-line-between-statements.js

@@ -473,13 +473,15 @@ module.exports = {
          * @private
          */
         function match(node, type) {
-            while (node.type === "LabeledStatement") {
-                node = node.body;
+            let innerStatementNode = node;
+
+            while (innerStatementNode.type === "LabeledStatement") {
+                innerStatementNode = innerStatementNode.body;
             }
             if (Array.isArray(type)) {
-                return type.some(match.bind(null, node));
+                return type.some(match.bind(null, innerStatementNode));
             }
-            return StatementTypes[type].test(node, sourceCode);
+            return StatementTypes[type].test(innerStatementNode, sourceCode);
         }
 
         /**

package/lib/rules/prefer-arrow-callback.js

@@ -64,9 +64,10 @@ function getVariableOfArguments(scope) {
  */
 function getCallbackInfo(node) {
     const retv = { isCallback: false, isLexicalThis: false };
+    let currentNode = node;
     let parent = node.parent;
 
-    while (node) {
+    while (currentNode) {
         switch (parent.type) {
 
             // Checks parents recursively.
@@ -77,7 +78,7 @@ function getCallbackInfo(node) {
 
             // Checks whether the parent node is `.bind(this)` call.
             case "MemberExpression":
-                if (parent.object === node &&
+                if (parent.object === currentNode &&
                     !parent.property.computed &&
                     parent.property.type === "Identifier" &&
                     parent.property.name === "bind" &&
@@ -97,7 +98,7 @@ function getCallbackInfo(node) {
             // Checks whether the node is a callback.
             case "CallExpression":
             case "NewExpression":
-                if (parent.callee !== node) {
+                if (parent.callee !== currentNode) {
                     retv.isCallback = true;
                 }
                 return retv;
@@ -106,7 +107,7 @@ function getCallbackInfo(node) {
                 return retv;
         }
 
-        node = parent;
+        currentNode = parent;
         parent = parent.parent;
     }
 

package/lib/rules/prefer-template.js

@@ -30,10 +30,12 @@ function isConcatenation(node) {
  * @returns {ASTNode} the top binary expression node in parents of a given node.
  */
 function getTopConcatBinaryExpression(node) {
-    while (isConcatenation(node.parent)) {
-        node = node.parent;
+    let currentNode = node;
+
+    while (isConcatenation(currentNode.parent)) {
+        currentNode = currentNode.parent;
     }
-    return node;
+    return currentNode;
 }
 
 /**

package/lib/rules/space-unary-ops.js

@@ -141,8 +141,6 @@ module.exports = {
          * @returns {void}
          */
         function checkUnaryWordOperatorForSpaces(node, firstToken, secondToken, word) {
-            word = word || firstToken.value;
-
             if (overrideExistsForOperator(word)) {
                 if (overrideEnforcesSpaces(word)) {
                     verifyWordHasSpaces(node, firstToken, secondToken, word);
@@ -276,7 +274,7 @@ module.exports = {
             const secondToken = tokens[1];
 
             if ((node.type === "NewExpression" || node.prefix) && firstToken.type === "Keyword") {
-                checkUnaryWordOperatorForSpaces(node, firstToken, secondToken);
+                checkUnaryWordOperatorForSpaces(node, firstToken, secondToken, firstToken.value);
                 return;
             }
 

package/lib/rules/spaced-comment.js

@@ -17,10 +17,7 @@ const astUtils = require("../ast-utils");
  * @returns {string} An escaped string.
  */
 function escape(s) {
-    const isOneChar = s.length === 1;
-
-    s = lodash.escapeRegExp(s);
-    return isOneChar ? s : `(?:${s})`;
+    return `(?:${lodash.escapeRegExp(s)})`;
 }
 
 /**
@@ -40,11 +37,10 @@ function escapeAndRepeat(s) {
  * @returns {string[]} A marker list.
  */
 function parseMarkersOption(markers) {
-    markers = markers ? markers.slice(0) : [];
 
     // `*` is a marker for JSDoc comments.
     if (markers.indexOf("*") === -1) {
-        markers.push("*");
+        return markers.concat("*");
     }
 
     return markers;
@@ -244,7 +240,7 @@ module.exports = {
         const balanced = config.block && config.block.balanced;
 
         const styleRules = ["block", "line"].reduce((rule, type) => {
-            const markers = parseMarkersOption(config[type] && config[type].markers || config.markers);
+            const markers = parseMarkersOption(config[type] && config[type].markers || config.markers || []);
             const exceptions = config[type] && config[type].exceptions || config.exceptions || [];
             const endNeverPattern = "[ \t]+$";
 

package/lib/rules/valid-jsdoc.js

@@ -420,14 +420,14 @@ module.exports = {
 
                 if (node.params) {
                     node.params.forEach((param, paramsIndex) => {
-                        if (param.type === "AssignmentPattern") {
-                            param = param.left;
-                        }
-
-                        const name = param.name;
+                        const bindingParam = param.type === "AssignmentPattern"
+                            ? param.left
+                            : param;
 
                         // TODO(nzakas): Figure out logical things to do with destructured, default, rest params
-                        if (param.type === "Identifier") {
+                        if (bindingParam.type === "Identifier") {
+                            const name = bindingParam.name;
+
                             if (jsdocParamNames[paramsIndex] && (name !== jsdocParamNames[paramsIndex])) {
                                 context.report({
                                     node: jsdocNode,

package/lib/rules/vars-on-top.js

@@ -125,23 +125,13 @@ module.exports = {
         //--------------------------------------------------------------------------
 
         return {
-            VariableDeclaration(node) {
-                const ancestors = context.getAncestors();
-                let parent = ancestors.pop();
-                let grandParent = ancestors.pop();
-
-                if (node.kind === "var") { // check variable is `var` type and not `let` or `const`
-                    if (parent.type === "ExportNamedDeclaration") {
-                        node = parent;
-                        parent = grandParent;
-                        grandParent = ancestors.pop();
-                    }
-
-                    if (parent.type === "Program") { // That means its a global variable
-                        globalVarCheck(node, parent);
-                    } else {
-                        blockScopeVarCheck(node, parent, grandParent);
-                    }
+            "VariableDeclaration[kind='var']"(node) {
+                if (node.parent.type === "ExportNamedDeclaration") {
+                    globalVarCheck(node.parent, node.parent.parent);
+                } else if (node.parent.type === "Program") {
+                    globalVarCheck(node, node.parent);
+                } else {
+                    blockScopeVarCheck(node, node.parent, node.parent.parent);
                 }
             }
         };

package/lib/timing.js

@@ -90,12 +90,10 @@ function display(data) {
             .join(" | ")
     ));
 
-    table.splice(1, 0, widths.map((w, index) => {
-        if (index !== 0 && index !== widths.length - 1) {
-            w++;
-        }
+    table.splice(1, 0, widths.map((width, index) => {
+        const extraAlignment = index !== 0 && index !== widths.length - 1 ? 2 : 1;
 
-        return ALIGN[index](":", w + 1, "-");
+        return ALIGN[index](":", width + extraAlignment, "-");
     }).join("|"));
 
     console.log(table.join("\n")); // eslint-disable-line no-console

package/lib/util/glob-util.js

@@ -95,20 +95,20 @@ const dotfilesPattern = /(?:(?:^\.)|(?:[/\\]\.))[^/\\.].*/;
  * Build a list of absolute filesnames on which ESLint will act.
  * Ignored files are excluded from the results, as are duplicates.
  *
- * @param   {string[]} globPatterns            Glob patterns.
- * @param   {Object}   [options]               An options object.
- * @param   {string}   [options.cwd]           CWD (considered for relative filenames)
- * @param   {boolean}  [options.ignore]        False disables use of .eslintignore.
- * @param   {string}   [options.ignorePath]    The ignore file to use instead of .eslintignore.
- * @param   {string}   [options.ignorePattern] A pattern of files to ignore.
+ * @param   {string[]} globPatterns                    Glob patterns.
+ * @param   {Object}   [providedOptions]               An options object.
+ * @param   {string}   [providedOptions.cwd]           CWD (considered for relative filenames)
+ * @param   {boolean}  [providedOptions.ignore]        False disables use of .eslintignore.
+ * @param   {string}   [providedOptions.ignorePath]    The ignore file to use instead of .eslintignore.
+ * @param   {string}   [providedOptions.ignorePattern] A pattern of files to ignore.
  * @returns {string[]} Resolved absolute filenames.
  */
-function listFilesToProcess(globPatterns, options) {
-    options = options || { ignore: true };
-    const files = [],
-        added = {};
+function listFilesToProcess(globPatterns, providedOptions) {
+    const options = providedOptions || { ignore: true };
+    const files = [];
+    const added = {};
 
-    const cwd = (options && options.cwd) || process.cwd();
+    const cwd = options.cwd || process.cwd();
 
     const getIgnorePaths = lodash.memoize(
         optionsObj =>

package/lib/util/interpolate.js

@@ -13,7 +13,11 @@ module.exports = (text, data) => {
     if (!data) {
         return text;
     }
-    return text.replace(/\{\{\s*([^{}]+?)\s*\}\}/g, (fullMatch, term) => {
+
+    // Substitution content for any {{ }} markers.
+    return text.replace(/\{\{([^{}]+?)\}\}/g, (fullMatch, termWithWhitespace) => {
+        const term = termWithWhitespace.trim();
+
         if (term in data) {
             return data[term];
         }

package/lib/util/naming.js

@@ -23,17 +23,18 @@ const NAMESPACE_REGEX = /^@.*\//i;
  * @private
  */
 function normalizePackageName(name, prefix) {
+    let normalizedName = name;
 
     /**
      * On Windows, name can come in with Windows slashes instead of Unix slashes.
      * Normalize to Unix first to avoid errors later on.
      * https://github.com/eslint/eslint/issues/5644
      */
-    if (name.indexOf("\\") > -1) {
-        name = pathUtil.convertPathToPosix(name);
+    if (normalizedName.indexOf("\\") > -1) {
+        normalizedName = pathUtil.convertPathToPosix(normalizedName);
     }
 
-    if (name.charAt(0) === "@") {
+    if (normalizedName.charAt(0) === "@") {
 
         /**
          * it's a scoped package
@@ -42,21 +43,21 @@ function normalizePackageName(name, prefix) {
         const scopedPackageShortcutRegex = new RegExp(`^(@[^/]+)(?:/(?:${prefix})?)?$`),
             scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`);
 
-        if (scopedPackageShortcutRegex.test(name)) {
-            name = name.replace(scopedPackageShortcutRegex, `$1/${prefix}`);
-        } else if (!scopedPackageNameRegex.test(name.split("/")[1])) {
+        if (scopedPackageShortcutRegex.test(normalizedName)) {
+            normalizedName = normalizedName.replace(scopedPackageShortcutRegex, `$1/${prefix}`);
+        } else if (!scopedPackageNameRegex.test(normalizedName.split("/")[1])) {
 
             /**
              * for scoped packages, insert the prefix after the first / unless
              * the path is already @scope/eslint or @scope/eslint-xxx-yyy
              */
-            name = name.replace(/^@([^/]+)\/(.*)$/, `@$1/${prefix}-$2`);
+            normalizedName = normalizedName.replace(/^@([^/]+)\/(.*)$/, `@$1/${prefix}-$2`);
         }
-    } else if (name.indexOf(`${prefix}-`) !== 0) {
-        name = `${prefix}-${name}`;
+    } else if (normalizedName.indexOf(`${prefix}-`) !== 0) {
+        normalizedName = `${prefix}-${normalizedName}`;
     }
 
-    return name;
+    return normalizedName;
 }
 
 /**

package/lib/util/npm-util.js

@@ -50,17 +50,15 @@ function findPackageJson(startDir) {
  * @returns {void}
  */
 function installSyncSaveDev(packages) {
-    if (!Array.isArray(packages)) {
-        packages = [packages];
-    }
-    const npmProcess = spawn.sync("npm", ["i", "--save-dev"].concat(packages),
+    const packageList = Array.isArray(packages) ? packages : [packages];
+    const npmProcess = spawn.sync("npm", ["i", "--save-dev"].concat(packageList),
         { stdio: "inherit" });
     const error = npmProcess.error;
 
     if (error && error.code === "ENOENT") {
-        const pluralS = packages.length > 1 ? "s" : "";
+        const pluralS = packageList.length > 1 ? "s" : "";
 
-        log.error(`Could not execute npm. Please install the following package${pluralS} with a package manager of your choice: ${packages.join(", ")}`);
+        log.error(`Could not execute npm. Please install the following package${pluralS} with a package manager of your choice: ${packageList.join(", ")}`);
     }
 }