eslint 6.5.1 → 6.7.2

package/lib/cli-engine/config-array/config-array.js

@@ -31,6 +31,7 @@
 //------------------------------------------------------------------------------
 
 const { ExtractedConfig } = require("./extracted-config");
+const { IgnorePattern } = require("./ignore-pattern");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -54,6 +55,7 @@ const { ExtractedConfig } = require("./extracted-config");
  * @property {InstanceType<OverrideTester>|null} criteria The tester for the `files` and `excludedFiles` of this config element.
  * @property {Record<string, boolean>|undefined} env The environment settings.
  * @property {Record<string, GlobalConf>|undefined} globals The global variable settings.
+ * @property {IgnorePattern|undefined} ignorePattern The ignore patterns.
  * @property {boolean|undefined} noInlineConfig The flag that disables directive comments.
  * @property {DependentParser|undefined} parser The parser loader.
  * @property {Object|undefined} parserOptions The parser options.
@@ -126,7 +128,6 @@ function isNonNullObject(x) {
  *
  * Assign every property values of `y` to `x` if `x` doesn't have the property.
  * If `x`'s property value is an object, it does recursive.
- *
  * @param {Object} target The destination to merge
  * @param {Object|undefined} source The source to merge.
  * @returns {void}
@@ -157,7 +158,6 @@ function mergeWithoutOverwrite(target, source) {
 /**
  * Merge plugins.
  * `target`'s definition is prior to `source`'s.
- *
  * @param {Record<string, DependentPlugin>} target The destination to merge
  * @param {Record<string, DependentPlugin>|undefined} source The source to merge.
  * @returns {void}
@@ -187,7 +187,6 @@ function mergePlugins(target, source) {
 /**
  * Merge rule configs.
  * `target`'s definition is prior to `source`'s.
- *
  * @param {Record<string, Array>} target The destination to merge
  * @param {Record<string, RuleConf>|undefined} source The source to merge.
  * @returns {void}
@@ -234,6 +233,7 @@ function mergeRuleConfigs(target, source) {
  */
 function createConfig(instance, indices) {
     const config = new ExtractedConfig();
+    const ignorePatterns = [];
 
     // Merge elements.
     for (const index of indices) {
@@ -263,6 +263,11 @@ function createConfig(instance, indices) {
             config.reportUnusedDisableDirectives = element.reportUnusedDisableDirectives;
         }
 
+        // Collect ignorePatterns
+        if (element.ignorePattern) {
+            ignorePatterns.push(element.ignorePattern);
+        }
+
         // Merge others.
         mergeWithoutOverwrite(config.env, element.env);
         mergeWithoutOverwrite(config.globals, element.globals);
@@ -272,6 +277,11 @@ function createConfig(instance, indices) {
         mergeRuleConfigs(config.rules, element.rules);
     }
 
+    // Create the predicate function for ignore patterns.
+    if (ignorePatterns.length > 0) {
+        config.ignores = IgnorePattern.createIgnore(ignorePatterns.reverse());
+    }
+
     return config;
 }
 
@@ -382,7 +392,6 @@ function ensurePluginMemberMaps(instance) {
  * You need to call `ConfigArray#extractConfig(filePath)` method in order to
  * extract, merge and get only the config data which is related to an arbitrary
  * file.
- *
  * @extends {Array<ConfigArrayElement>}
  */
 class ConfigArray extends Array {

package/lib/cli-engine/config-array/config-dependency.js

@@ -81,6 +81,7 @@ class ConfigDependency {
         this.importerPath = importerPath;
     }
 
+    // eslint-disable-next-line jsdoc/require-description
     /**
      * @returns {Object} a JSON compatible object.
      */
@@ -95,6 +96,7 @@ class ConfigDependency {
         return obj;
     }
 
+    // eslint-disable-next-line jsdoc/require-description
     /**
      * @returns {Object} an object to display by `console.log()`.
      */

package/lib/cli-engine/config-array/extracted-config.js

@@ -16,6 +16,8 @@
  */
 "use strict";
 
+const { IgnorePattern } = require("./ignore-pattern");
+
 // For VSCode intellisense
 /** @typedef {import("../../shared/types").ConfigData} ConfigData */
 /** @typedef {import("../../shared/types").GlobalConf} GlobalConf */
@@ -23,6 +25,17 @@
 /** @typedef {import("./config-dependency").DependentParser} DependentParser */
 /** @typedef {import("./config-dependency").DependentPlugin} DependentPlugin */
 
+/**
+ * Check if `xs` starts with `ys`.
+ * @template T
+ * @param {T[]} xs The array to check.
+ * @param {T[]} ys The array that may be the first part of `xs`.
+ * @returns {boolean} `true` if `xs` starts with `ys`.
+ */
+function startsWith(xs, ys) {
+    return xs.length >= ys.length && ys.every((y, i) => y === xs[i]);
+}
+
 /**
  * The class for extracted config data.
  */
@@ -47,6 +60,12 @@ class ExtractedConfig {
          */
         this.globals = {};
 
+        /**
+         * The glob patterns that ignore to lint.
+         * @type {(((filePath:string, dot?:boolean) => boolean) & { basePath:string; patterns:string[] }) | undefined}
+         */
+        this.ignores = void 0;
+
         /**
          * The flag that disables directive comments.
          * @type {boolean|undefined}
@@ -106,11 +125,19 @@ class ExtractedConfig {
             configNameOfNoInlineConfig: _ignore1,
             processor: _ignore2,
             /* eslint-enable no-unused-vars */
+            ignores,
             ...config
         } = this;
 
         config.parser = config.parser && config.parser.filePath;
         config.plugins = Object.keys(config.plugins).filter(Boolean).reverse();
+        config.ignorePatterns = ignores ? ignores.patterns : [];
+
+        // Strip the default patterns from `ignorePatterns`.
+        if (startsWith(config.ignorePatterns, IgnorePattern.DefaultPatterns)) {
+            config.ignorePatterns =
+                config.ignorePatterns.slice(IgnorePattern.DefaultPatterns.length);
+        }
 
         return config;
     }

package/lib/cli-engine/config-array/ignore-pattern.js

@@ -0,0 +1,231 @@
+/**
+ * @fileoverview `IgnorePattern` class.
+ *
+ * `IgnorePattern` class has the set of glob patterns and the base path.
+ *
+ * It provides two static methods.
+ *
+ * - `IgnorePattern.createDefaultIgnore(cwd)`
+ *      Create the default predicate function.
+ * - `IgnorePattern.createIgnore(ignorePatterns)`
+ *      Create the predicate function from multiple `IgnorePattern` objects.
+ *
+ * It provides two properties and a method.
+ *
+ * - `patterns`
+ *      The glob patterns that ignore to lint.
+ * - `basePath`
+ *      The base path of the glob patterns. If absolute paths existed in the
+ *      glob patterns, those are handled as relative paths to the base path.
+ * - `getPatternsRelativeTo(basePath)`
+ *      Get `patterns` as modified for a given base path. It modifies the
+ *      absolute paths in the patterns as prepending the difference of two base
+ *      paths.
+ *
+ * `ConfigArrayFactory` creates `IgnorePattern` objects when it processes
+ * `ignorePatterns` properties.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const assert = require("assert");
+const path = require("path");
+const ignore = require("ignore");
+const debug = require("debug")("eslint:ignore-pattern");
+
+/** @typedef {ReturnType<import("ignore").default>} Ignore */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Get the path to the common ancestor directory of given paths.
+ * @param {string[]} sourcePaths The paths to calculate the common ancestor.
+ * @returns {string} The path to the common ancestor directory.
+ */
+function getCommonAncestorPath(sourcePaths) {
+    let result = sourcePaths[0];
+
+    for (let i = 1; i < sourcePaths.length; ++i) {
+        const a = result;
+        const b = sourcePaths[i];
+
+        // Set the shorter one (it's the common ancestor if one includes the other).
+        result = a.length < b.length ? a : b;
+
+        // Set the common ancestor.
+        for (let j = 0, lastSepPos = 0; j < a.length && j < b.length; ++j) {
+            if (a[j] !== b[j]) {
+                result = a.slice(0, lastSepPos);
+                break;
+            }
+            if (a[j] === path.sep) {
+                lastSepPos = j;
+            }
+        }
+    }
+
+    return result || path.sep;
+}
+
+/**
+ * Make relative path.
+ * @param {string} from The source path to get relative path.
+ * @param {string} to The destination path to get relative path.
+ * @returns {string} The relative path.
+ */
+function relative(from, to) {
+    const relPath = path.relative(from, to);
+
+    if (path.sep === "/") {
+        return relPath;
+    }
+    return relPath.split(path.sep).join("/");
+}
+
+/**
+ * Get the trailing slash if existed.
+ * @param {string} filePath The path to check.
+ * @returns {string} The trailing slash if existed.
+ */
+function dirSuffix(filePath) {
+    const isDir = (
+        filePath.endsWith(path.sep) ||
+        (process.platform === "win32" && filePath.endsWith("/"))
+    );
+
+    return isDir ? "/" : "";
+}
+
+const DefaultPatterns = Object.freeze(["/node_modules/*", "/bower_components/*"]);
+const DotPatterns = Object.freeze([".*", "!../"]);
+
+//------------------------------------------------------------------------------
+// Public
+//------------------------------------------------------------------------------
+
+class IgnorePattern {
+
+    /**
+     * The default patterns.
+     * @type {string[]}
+     */
+    static get DefaultPatterns() {
+        return DefaultPatterns;
+    }
+
+    /**
+     * Create the default predicate function.
+     * @param {string} cwd The current working directory.
+     * @returns {((filePath:string, dot:boolean) => boolean) & {basePath:string; patterns:string[]}}
+     * The preficate function.
+     * The first argument is an absolute path that is checked.
+     * The second argument is the flag to not ignore dotfiles.
+     * If the predicate function returned `true`, it means the path should be ignored.
+     */
+    static createDefaultIgnore(cwd) {
+        return this.createIgnore([new IgnorePattern(DefaultPatterns, cwd)]);
+    }
+
+    /**
+     * Create the predicate function from multiple `IgnorePattern` objects.
+     * @param {IgnorePattern[]} ignorePatterns The list of ignore patterns.
+     * @returns {((filePath:string, dot?:boolean) => boolean) & {basePath:string; patterns:string[]}}
+     * The preficate function.
+     * The first argument is an absolute path that is checked.
+     * The second argument is the flag to not ignore dotfiles.
+     * If the predicate function returned `true`, it means the path should be ignored.
+     */
+    static createIgnore(ignorePatterns) {
+        debug("Create with: %o", ignorePatterns);
+
+        const basePath = getCommonAncestorPath(ignorePatterns.map(p => p.basePath));
+        const patterns = [].concat(
+            ...ignorePatterns.map(p => p.getPatternsRelativeTo(basePath))
+        );
+        const ig = ignore().add([...DotPatterns, ...patterns]);
+        const dotIg = ignore().add(patterns);
+
+        debug("  processed: %o", { basePath, patterns });
+
+        return Object.assign(
+            (filePath, dot = false) => {
+                assert(path.isAbsolute(filePath), "'filePath' should be an absolute path.");
+                const relPathRaw = relative(basePath, filePath);
+                const relPath = relPathRaw && (relPathRaw + dirSuffix(filePath));
+                const adoptedIg = dot ? dotIg : ig;
+                const result = relPath !== "" && adoptedIg.ignores(relPath);
+
+                debug("Check", { filePath, dot, relativePath: relPath, result });
+                return result;
+            },
+            { basePath, patterns }
+        );
+    }
+
+    /**
+     * Initialize a new `IgnorePattern` instance.
+     * @param {string[]} patterns The glob patterns that ignore to lint.
+     * @param {string} basePath The base path of `patterns`.
+     */
+    constructor(patterns, basePath) {
+        assert(path.isAbsolute(basePath), "'basePath' should be an absolute path.");
+
+        /**
+         * The glob patterns that ignore to lint.
+         * @type {string[]}
+         */
+        this.patterns = patterns;
+
+        /**
+         * The base path of `patterns`.
+         * @type {string}
+         */
+        this.basePath = basePath;
+
+        /**
+         * If `true` then patterns which don't start with `/` will match the paths to the outside of `basePath`. Defaults to `false`.
+         *
+         * It's set `true` for `.eslintignore`, `package.json`, and `--ignore-path` for backward compatibility.
+         * It's `false` as-is for `ignorePatterns` property in config files.
+         * @type {boolean}
+         */
+        this.loose = false;
+    }
+
+    /**
+     * Get `patterns` as modified for a given base path. It modifies the
+     * absolute paths in the patterns as prepending the difference of two base
+     * paths.
+     * @param {string} newBasePath The base path.
+     * @returns {string[]} Modifired patterns.
+     */
+    getPatternsRelativeTo(newBasePath) {
+        assert(path.isAbsolute(newBasePath), "'newBasePath' should be an absolute path.");
+        const { basePath, loose, patterns } = this;
+
+        if (newBasePath === basePath) {
+            return patterns;
+        }
+        const prefix = `/${relative(newBasePath, basePath)}`;
+
+        return patterns.map(pattern => {
+            const negative = pattern.startsWith("!");
+            const head = negative ? "!" : "";
+            const body = negative ? pattern.slice(1) : pattern;
+
+            if (body.startsWith("/") || body.startsWith("../")) {
+                return `${head}${prefix}${body}`;
+            }
+            return loose ? pattern : `${head}${prefix}/**/${body}`;
+        });
+    }
+}
+
+module.exports = { IgnorePattern };

package/lib/cli-engine/config-array/index.js

@@ -7,12 +7,14 @@
 const { ConfigArray, getUsedExtractedConfigs } = require("./config-array");
 const { ConfigDependency } = require("./config-dependency");
 const { ExtractedConfig } = require("./extracted-config");
+const { IgnorePattern } = require("./ignore-pattern");
 const { OverrideTester } = require("./override-tester");
 
 module.exports = {
     ConfigArray,
     ConfigDependency,
     ExtractedConfig,
+    IgnorePattern,
     OverrideTester,
     getUsedExtractedConfigs
 };

package/lib/cli-engine/config-array/override-tester.js

@@ -166,6 +166,7 @@ class OverrideTester {
         ));
     }
 
+    // eslint-disable-next-line jsdoc/require-description
     /**
      * @returns {Object} a JSON compatible object.
      */
@@ -182,6 +183,7 @@ class OverrideTester {
         };
     }
 
+    // eslint-disable-next-line jsdoc/require-description
     /**
      * @returns {Object} an object to display by `console.log()`.
      */

package/lib/cli-engine/config-array-factory.js

@@ -17,6 +17,12 @@
  *     Create a `ConfigArray` instance from a config file which is on a given
  *     directory. This tries to load `.eslintrc.*` or `package.json`. If not
  *     found, returns an empty `ConfigArray`.
+ * - `loadESLintIgnore(filePath)`
+ *     Create a `ConfigArray` instance from a config file that is `.eslintignore`
+ *     format. This is to handle `--ignore-path` option.
+ * - `loadDefaultESLintIgnore()`
+ *     Create a `ConfigArray` instance from `.eslintignore` or `package.json` in
+ *     the current working directory.
  *
  * `ConfigArrayFactory` class has the responsibility that loads configuration
  * files, including loading `extends`, `parser`, and `plugins`. The created
@@ -40,7 +46,12 @@ const stripComments = require("strip-json-comments");
 const { validateConfigSchema } = require("../shared/config-validator");
 const naming = require("../shared/naming");
 const ModuleResolver = require("../shared/relative-module-resolver");
-const { ConfigArray, ConfigDependency, OverrideTester } = require("./config-array");
+const {
+    ConfigArray,
+    ConfigDependency,
+    IgnorePattern,
+    OverrideTester
+} = require("./config-array");
 const debug = require("debug")("eslint:config-array-factory");
 
 //------------------------------------------------------------------------------
@@ -221,6 +232,26 @@ function loadPackageJSONConfigFile(filePath) {
     }
 }
 
+/**
+ * Loads a `.eslintignore` from a file.
+ * @param {string} filePath The filename to load.
+ * @returns {string[]} The ignore patterns from the file.
+ * @private
+ */
+function loadESLintIgnoreFile(filePath) {
+    debug(`Loading .eslintignore file: ${filePath}`);
+
+    try {
+        return readFile(filePath)
+            .split(/\r?\n/gu)
+            .filter(line => line.trim() !== "" && !line.startsWith("#"));
+    } catch (e) {
+        debug(`Error reading .eslintignore file: ${filePath}`);
+        e.message = `Cannot read .eslintignore file: ${filePath}\nError: ${e.message}`;
+        throw e;
+    }
+}
+
 /**
  * Creates an error to notify about a missing config to extend from.
  * @param {string} configName The name of the missing config.
@@ -403,6 +434,54 @@ class ConfigArrayFactory {
         );
     }
 
+    /**
+     * Load `.eslintignore` file.
+     * @param {string} filePath The path to a `.eslintignore` file to load.
+     * @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
+     */
+    loadESLintIgnore(filePath) {
+        const { cwd } = internalSlotsMap.get(this);
+        const absolutePath = path.resolve(cwd, filePath);
+        const name = path.relative(cwd, absolutePath);
+        const ignorePatterns = loadESLintIgnoreFile(absolutePath);
+
+        return createConfigArray(
+            this._normalizeESLintIgnoreData(ignorePatterns, absolutePath, name)
+        );
+    }
+
+    /**
+     * Load `.eslintignore` file in the current working directory.
+     * @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
+     */
+    loadDefaultESLintIgnore() {
+        const { cwd } = internalSlotsMap.get(this);
+        const eslintIgnorePath = path.resolve(cwd, ".eslintignore");
+        const packageJsonPath = path.resolve(cwd, "package.json");
+
+        if (fs.existsSync(eslintIgnorePath)) {
+            return this.loadESLintIgnore(eslintIgnorePath);
+        }
+        if (fs.existsSync(packageJsonPath)) {
+            const data = loadJSONConfigFile(packageJsonPath);
+
+            if (Object.hasOwnProperty.call(data, "eslintIgnore")) {
+                if (!Array.isArray(data.eslintIgnore)) {
+                    throw new Error("Package.json eslintIgnore property requires an array of paths");
+                }
+                return createConfigArray(
+                    this._normalizeESLintIgnoreData(
+                        data.eslintIgnore,
+                        packageJsonPath,
+                        "eslintIgnore in package.json"
+                    )
+                );
+            }
+        }
+
+        return new ConfigArray();
+    }
+
     /**
      * Load a given config file.
      * @param {string} filePath The path to a config file.
@@ -451,6 +530,30 @@ class ConfigArrayFactory {
         return null;
     }
 
+    /**
+     * Normalize a given `.eslintignore` data to config array elements.
+     * @param {string[]} ignorePatterns The patterns to ignore files.
+     * @param {string|undefined} filePath The file path of this config.
+     * @param {string|undefined} name The name of this config.
+     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.
+     * @private
+     */
+    *_normalizeESLintIgnoreData(ignorePatterns, filePath, name) {
+        const elements = this._normalizeObjectConfigData(
+            { ignorePatterns },
+            filePath,
+            name
+        );
+
+        // Set `ignorePattern.loose` flag for backward compatibility.
+        for (const element of elements) {
+            if (element.ignorePattern) {
+                element.ignorePattern.loose = true;
+            }
+            yield element;
+        }
+    }
+
     /**
      * Normalize a given config to an array.
      * @param {ConfigData} configData The config data to normalize.
@@ -494,6 +597,9 @@ class ConfigArrayFactory {
             if (element.criteria) {
                 element.criteria.basePath = basePath;
             }
+            if (element.ignorePattern) {
+                element.ignorePattern.basePath = basePath;
+            }
 
             /*
              * Merge the criteria; this is for only file extension processors in
@@ -526,6 +632,7 @@ class ConfigArrayFactory {
             env,
             extends: extend,
             globals,
+            ignorePatterns,
             noInlineConfig,
             parser: parserName,
             parserOptions,
@@ -541,6 +648,10 @@ class ConfigArrayFactory {
         name
     ) {
         const extendList = Array.isArray(extend) ? extend : [extend];
+        const ignorePattern = ignorePatterns && new IgnorePattern(
+            Array.isArray(ignorePatterns) ? ignorePatterns : [ignorePatterns],
+            filePath ? path.dirname(filePath) : internalSlotsMap.get(this).cwd
+        );
 
         // Flatten `extends`.
         for (const extendName of extendList.filter(Boolean)) {
@@ -569,6 +680,7 @@ class ConfigArrayFactory {
             criteria: null,
             env,
             globals,
+            ignorePattern,
             noInlineConfig,
             parser,
             parserOptions,
@@ -859,8 +971,14 @@ class ConfigArrayFactory {
         if (filePath) {
             try {
                 writeDebugLogForLoading(request, relativeTo, filePath);
+
+                const startTime = Date.now();
+                const pluginDefinition = require(filePath);
+
+                debug(`Plugin ${filePath} loaded in: ${Date.now() - startTime}ms`);
+
                 return new ConfigDependency({
-                    definition: normalizePlugin(require(filePath)),
+                    definition: normalizePlugin(pluginDefinition),
                     filePath,
                     id,
                     importerName,