eslint 9.11.1 → 9.12.0

package/lib/eslint/eslint-helpers.js

@@ -15,9 +15,7 @@ const fsp = fs.promises;
 const isGlob = require("is-glob");
 const hash = require("../cli-engine/hash");
 const minimatch = require("minimatch");
-const fswalk = require("@nodelib/fs.walk");
 const globParent = require("glob-parent");
-const isPathInside = require("is-path-inside");
 
 //-----------------------------------------------------------------------------
 // Fixup references
@@ -160,31 +158,28 @@ function isGlobPattern(pattern) {
  * @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 }) {
+async function globMatch({ basePath, pattern }) {
 
     let found = false;
+    const { hfs } = await import("@humanfs/node");
     const patternToUse = path.isAbsolute(pattern)
         ? normalizeToPosix(path.relative(basePath, pattern))
         : pattern;
 
     const matcher = new Minimatch(patternToUse, MINIMATCH_OPTIONS);
 
-    const fsWalkSettings = {
+    const walkSettings = {
 
-        deepFilter(entry) {
-            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
-
-            return !found && matcher.match(relativePath, true);
+        directoryFilter(entry) {
+            return !found && matcher.match(entry.path, true);
         },
 
         entryFilter(entry) {
-            if (found || entry.dirent.isDirectory()) {
+            if (found || entry.isDirectory) {
                 return false;
             }
 
-            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
-
-            if (matcher.match(relativePath)) {
+            if (matcher.match(entry.path)) {
                 found = true;
                 return true;
             }
@@ -193,25 +188,11 @@ function globMatch({ basePath, pattern }) {
         }
     };
 
-    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();
-    });
+    if (await hfs.isDirectory(basePath)) {
+        return hfs.walk(basePath, walkSettings).next().then(() => found);
+    }
 
+    return found;
 }
 
 /**
@@ -225,7 +206,7 @@ function globMatch({ basePath, pattern }) {
  *      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
+ * @param {ConfigLoader|LegacyConfigLoader} options.configLoader 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.
@@ -238,7 +219,7 @@ async function globSearch({
     basePath,
     patterns,
     rawPatterns,
-    configs,
+    configLoader,
     errorOnUnmatchedPattern
 }) {
 
@@ -277,94 +258,76 @@ async function globSearch({
      * search.
      */
     const unmatchedPatterns = new Set([...relativeToPatterns.keys()]);
+    const { hfs } = await import("@humanfs/node");
 
-    const filePaths = (await new Promise((resolve, reject) => {
-
-        let promiseRejected = false;
+    const walk = hfs.walk(
+        basePath,
+        {
+            async directoryFilter(entry) {
 
-        /**
-         * Wraps a boolean-returning filter function. The wrapped function will reject the promise if an error occurs.
-         * @param {Function} filter A filter function to wrap.
-         * @returns {Function} A function similar to the wrapped filter that rejects the promise if an error occurs.
-         */
-        function wrapFilter(filter) {
-            return (...args) => {
-
-                // No need to run the filter if an error has been thrown.
-                if (!promiseRejected) {
-                    try {
-                        return filter(...args);
-                    } catch (error) {
-                        promiseRejected = true;
-                        reject(error);
-                    }
+                if (!matchers.some(matcher => matcher.match(entry.path, true))) {
+                    return false;
                 }
-                return false;
-            };
-        }
 
-        fswalk.walk(
-            basePath,
-            {
-                deepFilter: wrapFilter(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: wrapFilter(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 has a config. If the file has no
-                             * config, that means there wasn't a match for the
-                             * pattern so it should not be removed.
-                             *
-                             * Performance note: `getConfig()` aggressively caches
-                             * results so there is no performance penalty for calling
-                             * it multiple times with the same argument.
-                             */
-                            if (pathMatches && configs.getConfig(entry.path)) {
-                                unmatchedPatterns.delete(matcher.pattern);
-                            }
-
-                            return pathMatches || previousValue;
-                        }, false)
-                        : matchers.some(matcher => matcher.match(relativePath));
-
-                    return matchesPattern && configs.getConfig(entry.path) !== void 0;
-                })
+                const absolutePath = path.resolve(basePath, entry.path);
+                const configs = await configLoader.loadConfigArrayForDirectory(absolutePath);
+
+                return !configs.isDirectoryIgnored(absolutePath);
             },
-            (error, entries) => {
+            async entryFilter(entry) {
+                const absolutePath = path.resolve(basePath, entry.path);
 
-                // If the promise is already rejected, calling `resolve` or `reject` will do nothing.
-                if (error) {
-                    reject(error);
-                } else {
-                    resolve(entries);
+                // entries may be directories or files so filter out directories
+                if (entry.isDirectory) {
+                    return false;
                 }
+
+                const configs = await configLoader.loadConfigArrayForFile(absolutePath);
+                const config = configs.getConfig(absolutePath);
+
+                /*
+                 * 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(entry.path);
+
+                        /*
+                         * We updated the unmatched patterns set only if the path
+                         * matches and the file has a config. If the file has no
+                         * config, that means there wasn't a match for the
+                         * pattern so it should not be removed.
+                         *
+                         * Performance note: `getConfig()` aggressively caches
+                         * results so there is no performance penalty for calling
+                         * it multiple times with the same argument.
+                         */
+                        if (pathMatches && config) {
+                            unmatchedPatterns.delete(matcher.pattern);
+                        }
+
+                        return pathMatches || previousValue;
+                    }, false)
+                    : matchers.some(matcher => matcher.match(entry.path));
+
+                return matchesPattern && config !== void 0;
             }
-        );
-    })).map(entry => entry.path);
+        }
+    );
+
+    const filePaths = [];
+
+    if (await hfs.isDirectory(basePath)) {
+        for await (const entry of walk) {
+            filePaths.push(path.resolve(basePath, entry.path));
+        }
+    }
 
     // now check to see if we have any unmatched patterns
     if (errorOnUnmatchedPattern && unmatchedPatterns.size > 0) {
@@ -426,14 +389,14 @@ async function throwErrorForUnmatchedPatterns({
  * @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
+ * @param {ConfigLoader|LegacyConfigLoader} options.configLoader The config loader 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 }) {
+async function globMultiSearch({ searches, configLoader, errorOnUnmatchedPattern }) {
 
     /*
      * For convenience, we normalized the search map into an array of objects.
@@ -452,7 +415,7 @@ async function globMultiSearch({ searches, configs, errorOnUnmatchedPattern }) {
                 basePath,
                 patterns,
                 rawPatterns,
-                configs,
+                configLoader,
                 errorOnUnmatchedPattern
             })
         )
@@ -505,7 +468,7 @@ async function globMultiSearch({ searches, configs, errorOnUnmatchedPattern }) {
  * @param {boolean} args.globInputPaths true to interpret glob patterns,
  *      false to not interpret glob patterns.
  * @param {string} args.cwd The current working directory to find from.
- * @param {FlatConfigArray} args.configs The configs for the current run.
+ * @param {ConfigLoader|LegacyConfigLoader} args.configLoader The config loeader for the current run.
  * @param {boolean} args.errorOnUnmatchedPattern Determines if an unmatched pattern
  *      should throw an error.
  * @returns {Promise<Array<string>>} The fully resolved file paths.
@@ -516,7 +479,7 @@ async function findFiles({
     patterns,
     globInputPaths,
     cwd,
-    configs,
+    configLoader,
     errorOnUnmatchedPattern
 }) {
 
@@ -526,6 +489,42 @@ async function findFiles({
     let rawPatterns = [];
     const searches = new Map([[cwd, { patterns: globbyPatterns, rawPatterns: [] }]]);
 
+    /*
+     * This part is a bit involved because we need to account for
+     * the different ways that the patterns can match directories.
+     * For each different way, we need to decide if we should look
+     * for a config file or just use the default config. (Directories
+     * without a config file always use the default config.)
+     *
+     * Here are the cases:
+     *
+     * 1. A directory is passed directly (e.g., "subdir"). In this case, we
+     * can assume that the user intends to lint this directory and we should
+     * not look for a config file in the parent directory, because the only
+     * reason to do that would be to ignore this directory (which we already
+     * know we don't want to do). Instead, we use the default config until we
+     * get to the directory that was passed, at which point we start looking
+     * for config files again.
+     *
+     * 2. A dot (".") or star ("*"). In this case, we want to read
+     * the config file in the current directory because the user is
+     * explicitly asking to lint the current directory. Note that "."
+     * will traverse into subdirectories while "*" will not.
+     *
+     * 3. A directory is passed in the form of "subdir/subsubdir".
+     * In this case, we don't want to look for a config file in the
+     * parent directory ("subdir"). We can skip looking for a config
+     * file until `entry.depth` is greater than 1 because there's no
+     * way that the pattern can match `entry.path` yet.
+     *
+     * 4. A directory glob pattern is passed (e.g., "subd*"). We want
+     * this case to act like case 2 because it's unclear whether or not
+     * any particular directory is meant to be traversed.
+     *
+     * 5. A recursive glob pattern is passed (e.g., "**"). We want this
+     * case to act like case 2.
+     */
+
     // check to see if we have explicit files and directories
     const filePaths = patterns.map(filePath => path.resolve(cwd, filePath));
     const stats = await Promise.all(
@@ -549,15 +548,10 @@ async function findFiles({
             // directories need extensions attached
             if (stat.isDirectory()) {
 
-                // 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));
+                if (!searches.has(filePath)) {
+                    searches.set(filePath, { patterns: [], rawPatterns: [] });
                 }
+                ({ patterns: globbyPatterns, rawPatterns } = searches.get(filePath));
 
                 globbyPatterns.push(`${normalizeToPosix(filePath)}/**`);
                 rawPatterns.push(pattern);
@@ -569,17 +563,17 @@ async function findFiles({
         // save patterns for later use based on whether globs are enabled
         if (globInputPaths && isGlobPattern(pattern)) {
 
+            /*
+             * We are grouping patterns by their glob parent. This is done to
+             * make it easier to determine when a config file should be loaded.
+             */
+
             const basePath = path.resolve(cwd, globParent(pattern));
 
-            // 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));
+            if (!searches.has(basePath)) {
+                searches.set(basePath, { patterns: [], rawPatterns: [] });
             }
+            ({ patterns: globbyPatterns, rawPatterns } = searches.get(basePath));
 
             globbyPatterns.push(filePath);
             rawPatterns.push(pattern);
@@ -596,7 +590,7 @@ async function findFiles({
     // now we are safe to do the search
     const globbyResults = await globMultiSearch({
         searches,
-        configs,
+        configLoader,
         errorOnUnmatchedPattern
     });