eslint 4.16.0 → 4.18.2

package/lib/rules/object-curly-newline.js

@@ -10,6 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("../ast-utils");
+const lodash = require("lodash");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -73,19 +74,57 @@ function normalizeOptionValue(value) {
  * Normalizes a given option value.
  *
  * @param {string|Object|undefined} options - An option value to parse.
- * @returns {{ObjectExpression: {multiline: boolean, minProperties: number}, ObjectPattern: {multiline: boolean, minProperties: number}}} Normalized option object.
+ * @returns {{
+ *   ObjectExpression: {multiline: boolean, minProperties: number, consistent: boolean},
+ *   ObjectPattern: {multiline: boolean, minProperties: number, consistent: boolean},
+ *   ImportDeclaration: {multiline: boolean, minProperties: number, consistent: boolean},
+ *   ExportNamedDeclaration : {multiline: boolean, minProperties: number, consistent: boolean}
+ * }} Normalized option object.
  */
 function normalizeOptions(options) {
-    if (options && (options.ObjectExpression || options.ObjectPattern)) {
+    const isNodeSpecificOption = lodash.overSome([lodash.isPlainObject, lodash.isString]);
+
+    if (lodash.isPlainObject(options) && lodash.some(options, isNodeSpecificOption)) {
         return {
             ObjectExpression: normalizeOptionValue(options.ObjectExpression),
-            ObjectPattern: normalizeOptionValue(options.ObjectPattern)
+            ObjectPattern: normalizeOptionValue(options.ObjectPattern),
+            ImportDeclaration: normalizeOptionValue(options.ImportDeclaration),
+            ExportNamedDeclaration: normalizeOptionValue(options.ExportDeclaration)
         };
     }
 
     const value = normalizeOptionValue(options);
 
-    return { ObjectExpression: value, ObjectPattern: value };
+    return { ObjectExpression: value, ObjectPattern: value, ImportDeclaration: value, ExportNamedDeclaration: value };
+}
+
+/**
+ * Determines if ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration
+ * node needs to be checked for missing line breaks
+ *
+ * @param {ASTNode} node - Node under inspection
+ * @param {Object} options - option specific to node type
+ * @param {Token} first - First object property
+ * @param {Token} last - Last object property
+ * @returns {boolean} `true` if node needs to be checked for missing line breaks
+ */
+function areLineBreaksRequired(node, options, first, last) {
+    let objectProperties;
+
+    if (node.type === "ObjectExpression" || node.type === "ObjectPattern") {
+        objectProperties = node.properties;
+    } else {
+
+        // is ImportDeclaration or ExportNamedDeclaration
+        objectProperties = node.specifiers;
+    }
+
+    return objectProperties.length >= options.minProperties ||
+        (
+            options.multiline &&
+            objectProperties.length > 0 &&
+            first.loc.start.line !== last.loc.end.line
+        );
 }
 
 //------------------------------------------------------------------------------
@@ -109,7 +148,9 @@ module.exports = {
                         type: "object",
                         properties: {
                             ObjectExpression: OPTION_VALUE,
-                            ObjectPattern: OPTION_VALUE
+                            ObjectPattern: OPTION_VALUE,
+                            ImportDeclaration: OPTION_VALUE,
+                            ExportDeclaration: OPTION_VALUE
                         },
                         additionalProperties: false,
                         minProperties: 1
@@ -125,32 +166,37 @@ module.exports = {
 
         /**
          * Reports a given node if it violated this rule.
-         *
-         * @param {ASTNode} node - A node to check. This is an ObjectExpression node or an ObjectPattern node.
-         * @param {{multiline: boolean, minProperties: number}} options - An option object.
+         * @param {ASTNode} node - A node to check. This is an ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration node.
+         * @param {{multiline: boolean, minProperties: number, consistent: boolean}} options - An option object.
          * @returns {void}
          */
         function check(node) {
             const options = normalizedOptions[node.type];
+
+            if (
+                (node.type === "ImportDeclaration" &&
+                    !node.specifiers.some(specifier => specifier.type === "ImportSpecifier")) ||
+                (node.type === "ExportNamedDeclaration" &&
+                    !node.specifiers.some(specifier => specifier.type === "ExportSpecifier"))
+            ) {
+                return;
+            }
+
             const openBrace = sourceCode.getFirstToken(node, token => token.value === "{");
+
             let closeBrace;
 
             if (node.typeAnnotation) {
                 closeBrace = sourceCode.getTokenBefore(node.typeAnnotation);
             } else {
-                closeBrace = sourceCode.getLastToken(node);
+                closeBrace = sourceCode.getLastToken(node, token => token.value === "}");
             }
 
             let first = sourceCode.getTokenAfter(openBrace, { includeComments: true });
             let last = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
-            const needsLinebreaks = (
-                node.properties.length >= options.minProperties ||
-                (
-                    options.multiline &&
-                    node.properties.length > 0 &&
-                    first.loc.start.line !== last.loc.end.line
-                )
-            );
+
+            const needsLineBreaks = areLineBreaksRequired(node, options, first, last);
+
             const hasCommentsFirstToken = astUtils.isCommentToken(first);
             const hasCommentsLastToken = astUtils.isCommentToken(last);
 
@@ -165,7 +211,7 @@ module.exports = {
             first = sourceCode.getTokenAfter(openBrace);
             last = sourceCode.getTokenBefore(closeBrace);
 
-            if (needsLinebreaks) {
+            if (needsLineBreaks) {
                 if (astUtils.isTokenOnSameLine(openBrace, first)) {
                     context.report({
                         message: "Expected a line break after this opening brace.",
@@ -244,7 +290,9 @@ module.exports = {
 
         return {
             ObjectExpression: check,
-            ObjectPattern: check
+            ObjectPattern: check,
+            ImportDeclaration: check,
+            ExportNamedDeclaration: check
         };
     }
 };

package/lib/rules/object-shorthand.js

@@ -131,7 +131,7 @@ module.exports = {
          *
          */
         function canHaveShorthand(property) {
-            return (property.kind !== "set" && property.kind !== "get" && property.type !== "SpreadProperty" && property.type !== "ExperimentalSpreadProperty");
+            return (property.kind !== "set" && property.kind !== "get" && property.type !== "SpreadElement" && property.type !== "SpreadProperty" && property.type !== "ExperimentalSpreadProperty");
         }
 
         /**
@@ -233,10 +233,11 @@ module.exports = {
             const keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]);
             let keyPrefix = "";
 
+            if (node.value.async) {
+                keyPrefix += "async ";
+            }
             if (node.value.generator) {
-                keyPrefix = "*";
-            } else if (node.value.async) {
-                keyPrefix = "async ";
+                keyPrefix += "*";
             }
 
             if (node.value.type === "FunctionExpression") {
@@ -273,10 +274,11 @@ module.exports = {
             const keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]);
             let functionHeader = "function";
 
+            if (node.value.async) {
+                functionHeader = `async ${functionHeader}`;
+            }
             if (node.value.generator) {
-                functionHeader = "function*";
-            } else if (node.value.async) {
-                functionHeader = "async function";
+                functionHeader = `${functionHeader}*`;
             }
 
             return fixer.replaceTextRange([node.range[0], lastKeyToken.range[1]], `${keyText}: ${functionHeader}`);

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

@@ -358,6 +358,12 @@ const StatementTypes = {
             node.loc.start.line !== node.loc.end.line &&
             isBlockLikeStatement(sourceCode, node)
     },
+    "multiline-expression": {
+        test: (node, sourceCode) =>
+            node.loc.start.line !== node.loc.end.line &&
+            node.type === "ExpressionStatement" &&
+            !isDirectivePrologue(node, sourceCode)
+    },
 
     block: newNodeTypeTester("BlockStatement"),
     empty: newNodeTypeTester("EmptyStatement"),

package/lib/rules/require-await.js

@@ -90,6 +90,11 @@ module.exports = {
 
             AwaitExpression() {
                 scopeInfo.hasAwait = true;
+            },
+            ForOfStatement(node) {
+                if (node.await) {
+                    scopeInfo.hasAwait = true;
+                }
             }
         };
     }

package/lib/rules/rest-spread-spacing.js

@@ -47,9 +47,15 @@ module.exports = {
             switch (node.type) {
                 case "SpreadElement":
                     type = "spread";
+                    if (node.parent.type === "ObjectExpression") {
+                        type += " property";
+                    }
                     break;
                 case "RestElement":
                     type = "rest";
+                    if (node.parent.type === "ObjectPattern") {
+                        type += " property";
+                    }
                     break;
                 case "ExperimentalSpreadProperty":
                     type = "spread property";

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

@@ -66,15 +66,6 @@ module.exports = {
                 node.argument && node.argument.type === "UnaryExpression" && node.argument.operator === "!";
         }
 
-        /**
-         * Check if the node's child argument is an "ObjectExpression"
-         * @param {ASTnode} node AST node
-         * @returns {boolean} Whether or not the argument's type is "ObjectExpression"
-         */
-        function isArgumentObjectExpression(node) {
-            return node.argument && node.argument.type && node.argument.type === "ObjectExpression";
-        }
-
         /**
          * Checks if an override exists for a given operator.
          * @param {string} operator Operator
@@ -125,7 +116,7 @@ module.exports = {
          * @returns {void}
          */
         function verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word) {
-            if (isArgumentObjectExpression(node)) {
+            if (astUtils.canTokensBeAdjacent(firstToken, secondToken)) {
                 if (secondToken.range[0] > firstToken.range[1]) {
                     context.report({
                         node,

package/lib/util/glob-util.js

@@ -8,7 +8,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const fs = require("fs"),
+const lodash = require("lodash"),
+    fs = require("fs"),
     path = require("path"),
     GlobSync = require("./glob"),
 
@@ -88,6 +89,8 @@ function resolveFileGlobPatterns(patterns, options) {
     return patterns.filter(p => p.length).map(processPathExtensions);
 }
 
+const dotfilesPattern = /(?:(?:^\.)|(?:[/\\]\.))[^/\\.].*/;
+
 /**
  * Build a list of absolute filesnames on which ESLint will act.
  * Ignored files are excluded from the results, as are duplicates.
@@ -107,6 +110,11 @@ function listFilesToProcess(globPatterns, options) {
 
     const cwd = (options && options.cwd) || process.cwd();
 
+    const getIgnorePaths = lodash.memoize(
+        optionsObj =>
+            new IgnoredPaths(optionsObj)
+    );
+
     /**
      * Executes the linter on a file defined by the `filename`. Skips
      * unsupported file extensions and any files that are already linted.
@@ -151,15 +159,20 @@ function listFilesToProcess(globPatterns, options) {
         const file = path.resolve(cwd, pattern);
 
         if (fs.existsSync(file) && fs.statSync(file).isFile()) {
-            const ignoredPaths = new IgnoredPaths(options);
+            const ignoredPaths = getIgnorePaths(options);
 
             addFile(fs.realpathSync(file), true, ignoredPaths);
         } else {
 
             // regex to find .hidden or /.hidden patterns, but not ./relative or ../relative
-            const globIncludesDotfiles = /(?:(?:^\.)|(?:[/\\]\.))[^/\\.].*/.test(pattern);
+            const globIncludesDotfiles = dotfilesPattern.test(pattern);
+            let newOptions = options;
+
+            if (!options.dotfiles) {
+                newOptions = Object.assign({}, options, { dotfiles: globIncludesDotfiles });
+            }
 
-            const ignoredPaths = new IgnoredPaths(Object.assign({}, options, { dotfiles: options.dotfiles || globIncludesDotfiles }));
+            const ignoredPaths = getIgnorePaths(newOptions);
             const shouldIgnore = ignoredPaths.getIgnoredFoldersGlobChecker();
             const globOptions = {
                 nodir: true,

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/npm-util.js

@@ -60,7 +60,7 @@ function installSyncSaveDev(packages) {
     if (error && error.code === "ENOENT") {
         const pluralS = packages.length > 1 ? "s" : "";
 
-        log.error(`Could not execute npm. Please install the following package${pluralS} with your package manager of choice: ${packages.join(", ")}`);
+        log.error(`Could not execute npm. Please install the following package${pluralS} with a package manager of your choice: ${packages.join(", ")}`);
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "4.16.0",
+  "version": "4.18.2",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -69,7 +69,7 @@
     "semver": "^5.3.0",
     "strip-ansi": "^4.0.0",
     "strip-json-comments": "~2.0.1",
-    "table": "^4.0.1",
+    "table": "4.0.2",
     "text-table": "~0.2.0"
   },
   "devDependencies": {

package/conf/default-config-options.js

@@ -1,29 +0,0 @@
-/**
- * @fileoverview Default config options
- * @author Teddy Katz
- */
-
-"use strict";
-
-/**
- * Freezes an object and all its nested properties
- * @param {Object} obj The object to deeply freeze
- * @returns {Object} `obj` after freezing it
- */
-function deepFreeze(obj) {
-    if (obj === null || typeof obj !== "object") {
-        return obj;
-    }
-
-    Object.keys(obj).map(key => obj[key]).forEach(deepFreeze);
-    return Object.freeze(obj);
-}
-
-module.exports = deepFreeze({
-    env: {},
-    globals: {},
-    rules: {},
-    settings: {},
-    parser: "espree",
-    parserOptions: {}
-});