eslint 8.25.0 → 8.27.0

package/lib/eslint/eslint-helpers.js

@@ -13,9 +13,30 @@ const path = require("path");
 const fs = require("fs");
 const fsp = fs.promises;
 const isGlob = require("is-glob");
-const globby = require("globby");
 const hash = require("../cli-engine/hash");
 const minimatch = require("minimatch");
+const util = require("util");
+const fswalk = require("@nodelib/fs.walk");
+const globParent = require("glob-parent");
+const isPathInside = require("is-path-inside");
+
+//-----------------------------------------------------------------------------
+// Fixup references
+//-----------------------------------------------------------------------------
+
+const doFsWalk = util.promisify(fswalk.walk);
+const Minimatch = minimatch.Minimatch;
+
+//-----------------------------------------------------------------------------
+// Types
+//-----------------------------------------------------------------------------
+
+/**
+ * @typedef {Object} GlobSearch
+ * @property {Array<string>} patterns The normalized patterns to use for a search.
+ * @property {Array<string>} rawPatterns The patterns as entered by the user
+ *      before doing any normalization.
+ */
 
 //-----------------------------------------------------------------------------
 // Errors
@@ -37,6 +58,30 @@ class NoFilesFoundError extends Error {
     }
 }
 
+/**
+ * The error type when a search fails to match multiple patterns.
+ */
+class UnmatchedSearchPatternsError extends Error {
+
+    /**
+     * @param {Object} options The options for the error.
+     * @param {string} options.basePath The directory that was searched.
+     * @param {Array<string>} options.unmatchedPatterns The glob patterns
+     *      which were not found.
+     * @param {Array<string>} options.patterns The glob patterns that were
+     *      searched.
+     * @param {Array<string>} options.rawPatterns The raw glob patterns that
+     *      were searched.
+     */
+    constructor({ basePath, unmatchedPatterns, patterns, rawPatterns }) {
+        super(`No files matching '${rawPatterns}' in '${basePath}' were found.`);
+        this.basePath = basePath;
+        this.patternsToCheck = unmatchedPatterns;
+        this.patterns = patterns;
+        this.rawPatterns = rawPatterns;
+    }
+}
+
 /**
  * The error type when there are files matched by a glob, but all of them have been ignored.
  */
@@ -97,6 +142,323 @@ function isGlobPattern(pattern) {
     return isGlob(path.sep === "\\" ? normalizeToPosix(pattern) : pattern);
 }
 
+
+/**
+ * Determines if a given glob pattern will return any results.
+ * Used primarily to help with useful error messages.
+ * @param {Object} options The options for the function.
+ * @param {string} options.basePath The directory to search.
+ * @param {string} options.pattern A glob pattern to match.
+ * @returns {Promise<boolean>} True if there is a glob match, false if not.
+ */
+function globMatch({ basePath, pattern }) {
+
+    let found = false;
+    const patternToUse = path.isAbsolute(pattern)
+        ? normalizeToPosix(path.relative(basePath, pattern))
+        : pattern;
+
+    const matcher = new Minimatch(patternToUse);
+
+    const fsWalkSettings = {
+
+        deepFilter(entry) {
+            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+
+            return !found && matcher.match(relativePath, true);
+        },
+
+        entryFilter(entry) {
+            if (found || entry.dirent.isDirectory()) {
+                return false;
+            }
+
+            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+
+            if (matcher.match(relativePath)) {
+                found = true;
+                return true;
+            }
+
+            return false;
+        }
+    };
+
+    return new Promise(resolve => {
+
+        // using a stream so we can exit early because we just need one match
+        const globStream = fswalk.walkStream(basePath, fsWalkSettings);
+
+        globStream.on("data", () => {
+            globStream.destroy();
+            resolve(true);
+        });
+
+        // swallow errors as they're not important here
+        globStream.on("error", () => { });
+
+        globStream.on("end", () => {
+            resolve(false);
+        });
+        globStream.read();
+    });
+
+}
+
+/**
+ * Searches a directory looking for matching glob patterns. This uses
+ * the config array's logic to determine if a directory or file should
+ * be ignored, so it is consistent with how ignoring works throughout
+ * ESLint.
+ * @param {Object} options The options for this function.
+ * @param {string} options.basePath The directory to search.
+ * @param {Array<string>} options.patterns An array of glob patterns
+ *      to match.
+ * @param {Array<string>} options.rawPatterns An array of glob patterns
+ *      as the user inputted them. Used for errors.
+ * @param {FlatConfigArray} options.configs The config array to use for
+ *      determining what to ignore.
+ * @param {boolean} options.errorOnUnmatchedPattern Determines if an error
+ *      should be thrown when a pattern is unmatched.
+ * @returns {Promise<Array<string>>} An array of matching file paths
+ *      or an empty array if there are no matches.
+ * @throws {UnmatchedSearchPatternsErrror} If there is a pattern that doesn't
+ *      match any files.
+ */
+async function globSearch({
+    basePath,
+    patterns,
+    rawPatterns,
+    configs,
+    errorOnUnmatchedPattern
+}) {
+
+    if (patterns.length === 0) {
+        return [];
+    }
+
+    /*
+     * In this section we are converting the patterns into Minimatch
+     * instances for performance reasons. Because we are doing the same
+     * matches repeatedly, it's best to compile those patterns once and
+     * reuse them multiple times.
+     *
+     * To do that, we convert any patterns with an absolute path into a
+     * relative path and normalize it to Posix-style slashes. We also keep
+     * track of the relative patterns to map them back to the original
+     * patterns, which we need in order to throw an error if there are any
+     * unmatched patterns.
+     */
+    const relativeToPatterns = new Map();
+    const matchers = patterns.map((pattern, i) => {
+        const patternToUse = path.isAbsolute(pattern)
+            ? normalizeToPosix(path.relative(basePath, pattern))
+            : pattern;
+
+        relativeToPatterns.set(patternToUse, patterns[i]);
+
+        return new minimatch.Minimatch(patternToUse);
+    });
+
+    /*
+     * We track unmatched patterns because we may want to throw an error when
+     * they occur. To start, this set is initialized with all of the patterns.
+     * Every time a match occurs, the pattern is removed from the set, making
+     * it easy to tell if we have any unmatched patterns left at the end of
+     * search.
+     */
+    const unmatchedPatterns = new Set([...relativeToPatterns.keys()]);
+
+    const filePaths = (await doFsWalk(basePath, {
+
+        deepFilter(entry) {
+            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+            const matchesPattern = matchers.some(matcher => matcher.match(relativePath, true));
+
+            return matchesPattern && !configs.isDirectoryIgnored(entry.path);
+        },
+        entryFilter(entry) {
+            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+
+            // entries may be directories or files so filter out directories
+            if (entry.dirent.isDirectory()) {
+                return false;
+            }
+
+            /*
+             * Optimization: We need to track when patterns are left unmatched
+             * and so we use `unmatchedPatterns` to do that. There is a bit of
+             * complexity here because the same file can be matched by more than
+             * one pattern. So, when we start, we actually need to test every
+             * pattern against every file. Once we know there are no remaining
+             * unmatched patterns, then we can switch to just looking for the
+             * first matching pattern for improved speed.
+             */
+            const matchesPattern = unmatchedPatterns.size > 0
+                ? matchers.reduce((previousValue, matcher) => {
+                    const pathMatches = matcher.match(relativePath);
+
+                    /*
+                     * We updated the unmatched patterns set only if the path
+                     * matches and the file isn't ignored. If the file is
+                     * ignored, that means there wasn't a match for the
+                     * pattern so it should not be removed.
+                     *
+                     * Performance note: isFileIgnored() aggressively caches
+                     * results so there is no performance penalty for calling
+                     * it twice with the same argument.
+                     */
+                    if (pathMatches && !configs.isFileIgnored(entry.path)) {
+                        unmatchedPatterns.delete(matcher.pattern);
+                    }
+
+                    return pathMatches || previousValue;
+                }, false)
+                : matchers.some(matcher => matcher.match(relativePath));
+
+            return matchesPattern && !configs.isFileIgnored(entry.path);
+        }
+
+    })).map(entry => entry.path);
+
+    // now check to see if we have any unmatched patterns
+    if (errorOnUnmatchedPattern && unmatchedPatterns.size > 0) {
+        throw new UnmatchedSearchPatternsError({
+            basePath,
+            unmatchedPatterns: [...unmatchedPatterns].map(
+                pattern => relativeToPatterns.get(pattern)
+            ),
+            patterns,
+            rawPatterns
+        });
+    }
+
+    return filePaths;
+}
+
+/**
+ * Checks to see if there are any ignored results for a given search. This
+ * happens either when there are unmatched patterns during a search or if
+ * a search returns no results.
+ * @param {Object} options The options for this function.
+ * @param {string} options.basePath The directory to search.
+ * @param {Array<string>} options.patterns An array of glob patterns
+ *      that were used in the original search.
+ * @param {Array<string>} options.rawPatterns An array of glob patterns
+ *      as the user inputted them. Used for errors.
+ * @param {Array<string>} options.patternsToCheck An array of glob patterns
+ *      to use for this check.
+ * @returns {void}
+ * @throws {NoFilesFoundError} If there is a pattern that doesn't match
+ *      any files and `errorOnUnmatchedPattern` is true.
+ * @throws {AllFilesIgnoredError} If there is a pattern that matches files
+ *      when there are no ignores.
+ */
+async function checkForIgnoredResults({
+    basePath,
+    patterns,
+    rawPatterns,
+    patternsToCheck = patterns
+}) {
+
+    for (const pattern of patternsToCheck) {
+
+        const patternHasMatch = await globMatch({
+            basePath,
+            pattern
+        });
+
+        if (patternHasMatch) {
+            throw new AllFilesIgnoredError(
+                rawPatterns[patterns.indexOf(pattern)]
+            );
+        }
+    }
+
+    // if we get here there are truly no matches
+    throw new NoFilesFoundError(
+        rawPatterns[patterns.indexOf(patternsToCheck[0])],
+        true
+    );
+}
+
+/**
+ * Performs multiple glob searches in parallel.
+ * @param {Object} options The options for this function.
+ * @param {Map<string,GlobSearch>} options.searches
+ *      An array of glob patterns to match.
+ * @param {FlatConfigArray} options.configs The config array to use for
+ *      determining what to ignore.
+ * @param {boolean} options.errorOnUnmatchedPattern Determines if an
+ *      unmatched glob pattern should throw an error.
+ * @returns {Promise<Array<string>>} An array of matching file paths
+ *      or an empty array if there are no matches.
+ */
+async function globMultiSearch({ searches, configs, errorOnUnmatchedPattern }) {
+
+    /*
+     * For convenience, we normalized the search map into an array of objects.
+     * Next, we filter out all searches that have no patterns. This happens
+     * primarily for the cwd, which is prepopulated in the searches map as an
+     * optimization. However, if it has no patterns, it means all patterns
+     * occur outside of the cwd and we can safely filter out that search.
+     */
+    const normalizedSearches = [...searches].map(
+        ([basePath, { patterns, rawPatterns }]) => ({ basePath, patterns, rawPatterns })
+    ).filter(({ patterns }) => patterns.length > 0);
+
+    const results = await Promise.allSettled(
+        normalizedSearches.map(
+            ({ basePath, patterns, rawPatterns }) => globSearch({
+                basePath,
+                patterns,
+                rawPatterns,
+                configs,
+                errorOnUnmatchedPattern
+            })
+        )
+    );
+
+    const filePaths = [];
+
+    for (let i = 0; i < results.length; i++) {
+
+        const result = results[i];
+        const currentSearch = normalizedSearches[i];
+
+        if (result.status === "fulfilled") {
+
+            // if the search was successful just add the results
+            if (result.value.length > 0) {
+                filePaths.push(...result.value);
+            }
+
+            continue;
+        }
+
+        // if we make it here then there was an error
+        const error = result.reason;
+
+        // unexpected errors should be re-thrown
+        if (!error.basePath) {
+            throw error;
+        }
+
+        if (errorOnUnmatchedPattern) {
+
+            await checkForIgnoredResults({
+                ...currentSearch,
+                patternsToCheck: error.patternsToCheck
+            });
+
+        }
+
+    }
+
+    return [...new Set(filePaths)];
+
+}
+
 /**
  * Finds all files matching the options specified.
  * @param {Object} args The arguments objects.
@@ -120,8 +482,10 @@ async function findFiles({
 }) {
 
     const results = [];
-    const globbyPatterns = [];
     const missingPatterns = [];
+    let globbyPatterns = [];
+    let rawPatterns = [];
+    const searches = new Map([[cwd, { patterns: globbyPatterns, rawPatterns: [] }]]);
 
     // check to see if we have explicit files and directories
     const filePaths = patterns.map(filePath => path.resolve(cwd, filePath));
@@ -142,76 +506,25 @@ async function findFiles({
             if (stat.isFile()) {
                 results.push({
                     filePath,
-                    ignored: configs.isIgnored(filePath)
+                    ignored: configs.isFileIgnored(filePath)
                 });
             }
 
             // directories need extensions attached
             if (stat.isDirectory()) {
 
-                // filePatterns are all relative to cwd
-                const filePatterns = configs.files
-                    .filter(filePattern => {
-
-                        // can only do this for strings, not functions
-                        if (typeof filePattern !== "string") {
-                            return false;
-                        }
-
-                        // patterns starting with ** always apply
-                        if (filePattern.startsWith("**")) {
-                            return true;
-                        }
-
-                        // patterns ending with * are not used for file search
-                        if (filePattern.endsWith("*")) {
-                            return false;
-                        }
-
-                        // not sure how to handle negated patterns yet
-                        if (filePattern.startsWith("!")) {
-                            return false;
-                        }
-
-                        // check if the pattern would be inside the config base path or not
-                        const fullFilePattern = path.join(cwd, filePattern);
-                        const patternRelativeToConfigBasePath = path.relative(configs.basePath, fullFilePattern);
-
-                        if (patternRelativeToConfigBasePath.startsWith("..")) {
-                            return false;
-                        }
-
-                        // check if the pattern matches
-                        if (minimatch(filePath, path.dirname(fullFilePattern), { partial: true })) {
-                            return true;
-                        }
-
-                        // check if the pattern is inside the directory or not
-                        const patternRelativeToFilePath = path.relative(filePath, fullFilePattern);
-
-                        if (patternRelativeToFilePath.startsWith("..")) {
-                            return false;
-                        }
-
-                        return true;
-                    })
-                    .map(filePattern => {
-                        if (filePattern.startsWith("**")) {
-                            return path.join(pattern, filePattern);
-                        }
-
-                        // adjust the path to be relative to the cwd
-                        return path.relative(
-                            cwd,
-                            path.join(configs.basePath, filePattern)
-                        );
-                    })
-                    .map(normalizeToPosix);
-
-                if (filePatterns.length) {
-                    globbyPatterns.push(...filePatterns);
+                // group everything in cwd together and split out others
+                if (isPathInside(filePath, cwd)) {
+                    ({ patterns: globbyPatterns, rawPatterns } = searches.get(cwd));
+                } else {
+                    if (!searches.has(filePath)) {
+                        searches.set(filePath, { patterns: [], rawPatterns: [] });
+                    }
+                    ({ patterns: globbyPatterns, rawPatterns } = searches.get(filePath));
                 }
 
+                globbyPatterns.push(`${normalizeToPosix(filePath)}/**`);
+                rawPatterns.push(pattern);
             }
 
             return;
@@ -219,47 +532,37 @@ async function findFiles({
 
         // save patterns for later use based on whether globs are enabled
         if (globInputPaths && isGlobPattern(filePath)) {
-            globbyPatterns.push(pattern);
-        } else {
-            missingPatterns.push(pattern);
-        }
-    });
-
-    // note: globbyPatterns can be an empty array
-    const globbyResults = (await globby(globbyPatterns, {
-        cwd,
-        absolute: true,
-        ignore: configs.ignores.filter(matcher => typeof matcher === "string")
-    }));
-
-    // if there are no results, tell the user why
-    if (!results.length && !globbyResults.length) {
-
-        // try globby without ignoring anything
-        /* eslint-disable no-unreachable-loop -- We want to exit early. */
-        for (const globbyPattern of globbyPatterns) {
 
-            /* eslint-disable-next-line no-unused-vars -- Want to exit early. */
-            for await (const filePath of globby.stream(globbyPattern, { cwd, absolute: true })) {
+            const basePath = globParent(filePath);
 
-                // files were found but ignored
-                throw new AllFilesIgnoredError(globbyPattern);
+            // group in cwd if possible and split out others
+            if (isPathInside(basePath, cwd)) {
+                ({ patterns: globbyPatterns, rawPatterns } = searches.get(cwd));
+            } else {
+                if (!searches.has(basePath)) {
+                    searches.set(basePath, { patterns: [], rawPatterns: [] });
+                }
+                ({ patterns: globbyPatterns, rawPatterns } = searches.get(basePath));
             }
 
-            // no files were found
-            if (errorOnUnmatchedPattern) {
-                throw new NoFilesFoundError(globbyPattern, globInputPaths);
-            }
+            globbyPatterns.push(filePath);
+            rawPatterns.push(pattern);
+        } else {
+            missingPatterns.push(pattern);
         }
-        /* eslint-enable no-unreachable-loop -- Go back to normal. */
-
-    }
+    });
 
     // there were patterns that didn't match anything, tell the user
     if (errorOnUnmatchedPattern && missingPatterns.length) {
         throw new NoFilesFoundError(missingPatterns[0], globInputPaths);
     }
 
+    // now we are safe to do the search
+    const globbyResults = await globMultiSearch({
+        searches,
+        configs,
+        errorOnUnmatchedPattern
+    });
 
     return [
         ...results,