ava 3.15.0 → 4.0.0

package/lib/glob-helpers.cjs

@@ -0,0 +1,140 @@
+'use strict';
+const path = require('path');
+const process = require('process');
+
+const ignoreByDefault = require('ignore-by-default');
+const picomatch = require('picomatch');
+const slash = require('slash');
+
+const defaultIgnorePatterns = [...ignoreByDefault.directories(), '**/node_modules'];
+exports.defaultIgnorePatterns = defaultIgnorePatterns;
+
+const defaultPicomatchIgnorePatterns = [
+	...defaultIgnorePatterns,
+	// Unlike globby(), picomatch needs a complete pattern when ignoring directories.
+	...defaultIgnorePatterns.map(pattern => `${pattern}/**/*`),
+];
+
+const defaultMatchNoIgnore = picomatch(defaultPicomatchIgnorePatterns);
+
+const matchingCache = new WeakMap();
+const processMatchingPatterns = input => {
+	let result = matchingCache.get(input);
+	if (!result) {
+		const ignore = [...defaultPicomatchIgnorePatterns];
+		const patterns = input.filter(pattern => {
+			if (pattern.startsWith('!')) {
+				// Unlike globby(), picomatch needs a complete pattern when ignoring directories.
+				ignore.push(pattern.slice(1), `${pattern.slice(1)}/**/*`);
+				return false;
+			}
+
+			return true;
+		});
+
+		result = {
+			match: picomatch(patterns, {ignore}),
+			matchNoIgnore: picomatch(patterns),
+			individualMatchers: patterns.map(pattern => ({pattern, match: picomatch(pattern, {ignore})})),
+		};
+		matchingCache.set(input, result);
+	}
+
+	return result;
+};
+
+exports.processMatchingPatterns = processMatchingPatterns;
+
+const matchesIgnorePatterns = (file, patterns) => {
+	const {matchNoIgnore} = processMatchingPatterns(patterns);
+	return matchNoIgnore(file) || defaultMatchNoIgnore(file);
+};
+
+function classify(file, {cwd, extensions, filePatterns, ignoredByWatcherPatterns}) {
+	file = normalizeFileForMatching(cwd, file);
+	return {
+		isIgnoredByWatcher: matchesIgnorePatterns(file, ignoredByWatcherPatterns),
+		isTest: hasExtension(extensions, file) && !isHelperish(file) && filePatterns.length > 0 && matches(file, filePatterns),
+	};
+}
+
+exports.classify = classify;
+
+const hasExtension = (extensions, file) => extensions.includes(path.extname(file).slice(1));
+
+exports.hasExtension = hasExtension;
+
+function isHelperish(file) { // Assume file has been normalized already.
+	// File names starting with an underscore are deemed "helpers".
+	if (path.basename(file).startsWith('_')) {
+		return true;
+	}
+
+	// This function assumes the file has been normalized. If it couldn't be,
+	// don't check if it's got a parent directory that starts with an underscore.
+	// Deem it not a "helper".
+	if (path.isAbsolute(file)) {
+		return false;
+	}
+
+	// If the file has a parent directory that starts with only a single
+	// underscore, it's deemed a "helper".
+	return path.dirname(file).split('/').some(dir => /^_(?:$|[^_])/.test(dir));
+}
+
+exports.isHelperish = isHelperish;
+
+function matches(file, patterns) {
+	const {match} = processMatchingPatterns(patterns);
+	return match(file);
+}
+
+exports.matches = matches;
+
+function normalizeFileForMatching(cwd, file) {
+	if (process.platform === 'win32') {
+		cwd = slash(cwd);
+		file = slash(file);
+	}
+
+	// Note that if `file` is outside `cwd` we can't normalize it. If this turns
+	// out to be a real-world scenario we may have to make changes in calling code
+	// to make sure the file isn't even selected for matching.
+	if (!file.startsWith(cwd)) {
+		return file;
+	}
+
+	// Assume `cwd` does *not* end in a slash.
+	return file.slice(cwd.length + 1);
+}
+
+exports.normalizeFileForMatching = normalizeFileForMatching;
+
+function normalizePattern(pattern) {
+	// Always use `/` in patterns, harmonizing matching across platforms
+	if (process.platform === 'win32') {
+		pattern = slash(pattern);
+	}
+
+	if (pattern.endsWith('/')) {
+		pattern = pattern.slice(0, -1);
+	}
+
+	if (pattern.startsWith('./')) {
+		return pattern.slice(2);
+	}
+
+	if (pattern.startsWith('!./')) {
+		return `!${pattern.slice(3)}`;
+	}
+
+	return pattern;
+}
+
+exports.normalizePattern = normalizePattern;
+
+function normalizePatterns(patterns) {
+	return patterns.map(pattern => normalizePattern(pattern));
+}
+
+exports.normalizePatterns = normalizePatterns;

package/lib/globs.js

@@ -1,54 +1,36 @@
-'use strict';
-const path = require('path');
-const globby = require('globby');
-const ignoreByDefault = require('ignore-by-default');
-const picomatch = require('picomatch');
-const slash = require('slash');
-const providerManager = require('./provider-manager');
-
-const defaultIgnorePatterns = [...ignoreByDefault.directories(), '**/node_modules'];
-const defaultPicomatchIgnorePatterns = [
-	...defaultIgnorePatterns,
-	// Unlike globby(), picomatch needs a complete pattern when ignoring directories.
-	...defaultIgnorePatterns.map(pattern => `${pattern}/**/*`)
-];
-
-const defaultMatchNoIgnore = picomatch(defaultPicomatchIgnorePatterns);
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {globby, globbySync} from 'globby';
+
+import {
+	defaultIgnorePatterns,
+	hasExtension,
+	normalizeFileForMatching,
+	normalizePatterns,
+	processMatchingPatterns,
+} from './glob-helpers.cjs';
+
+export {
+	classify,
+	isHelperish,
+	matches,
+	normalizePattern,
+	defaultIgnorePatterns,
+	hasExtension,
+	normalizeFileForMatching,
+	normalizePatterns,
+} from './glob-helpers.cjs';
 
 const defaultIgnoredByWatcherPatterns = [
 	'**/*.snap.md', // No need to rerun tests when the Markdown files change.
 	'ava.config.js', // Config is not reloaded so avoid rerunning tests when it changes.
-	'ava.config.cjs' // Config is not reloaded so avoid rerunning tests when it changes.
+	'ava.config.cjs', // Config is not reloaded so avoid rerunning tests when it changes.
 ];
 
 const buildExtensionPattern = extensions => extensions.length === 1 ? extensions[0] : `{${extensions.join(',')}}`;
 
-function normalizePattern(pattern) {
-	// Always use `/` in patterns, harmonizing matching across platforms
-	if (process.platform === 'win32') {
-		pattern = slash(pattern);
-	}
-
-	if (pattern.startsWith('./')) {
-		return pattern.slice(2);
-	}
-
-	if (pattern.startsWith('!./')) {
-		return `!${pattern.slice(3)}`;
-	}
-
-	return pattern;
-}
-
-exports.normalizePattern = normalizePattern;
-
-function normalizePatterns(patterns) {
-	return patterns.map(pattern => normalizePattern(pattern));
-}
-
-exports.normalizePatterns = normalizePatterns;
-
-function normalizeGlobs({extensions, files: filePatterns, ignoredByWatcher: ignoredByWatcherPatterns, providers}) {
+export function normalizeGlobs({extensions, files: filePatterns, ignoredByWatcher: ignoredByWatcherPatterns, providers}) {
 	if (filePatterns !== undefined && (!Array.isArray(filePatterns) || filePatterns.length === 0)) {
 		throw new Error('The ’files’ configuration must be an array containing glob patterns.');
 	}
@@ -68,7 +50,7 @@ function normalizeGlobs({extensions, files: filePatterns, ignoredByWatcher: igno
 		`**/test/**/*.${extensionPattern}`,
 		`**/tests/**/*.${extensionPattern}`,
 		'!**/__tests__/**/__{helper,fixture}?(s)__/**/*',
-		'!**/test?(s)/**/{helper,fixture}?(s)/**/*'
+		'!**/test?(s)/**/{helper,fixture}?(s)/**/*',
 	];
 
 	if (filePatterns) {
@@ -84,40 +66,36 @@ function normalizeGlobs({extensions, files: filePatterns, ignoredByWatcher: igno
 
 	ignoredByWatcherPatterns = ignoredByWatcherPatterns ? [...defaultIgnoredByWatcherPatterns, ...normalizePatterns(ignoredByWatcherPatterns)] : [...defaultIgnoredByWatcherPatterns];
 
-	for (const {level, main} of providers) {
-		if (level >= providerManager.levels.pathRewrites) {
-			({filePatterns, ignoredByWatcherPatterns} = main.updateGlobs({filePatterns, ignoredByWatcherPatterns}));
-		}
+	for (const {main} of providers) {
+		({filePatterns, ignoredByWatcherPatterns} = main.updateGlobs({filePatterns, ignoredByWatcherPatterns}));
 	}
 
 	return {extensions, filePatterns, ignoredByWatcherPatterns};
 }
 
-exports.normalizeGlobs = normalizeGlobs;
-
-const hasExtension = (extensions, file) => extensions.includes(path.extname(file).slice(1));
-
-exports.hasExtension = hasExtension;
+const globOptions = {
+	// Globs should work relative to the cwd value only (this should be the
+	// project directory that AVA is run in).
+	absolute: false,
+	braceExpansion: true,
+	caseSensitiveMatch: false,
+	dot: false,
+	expandDirectories: false,
+	extglob: true,
+	followSymbolicLinks: true,
+	gitignore: false,
+	globstar: true,
+	ignore: defaultIgnorePatterns,
+	baseNameMatch: false,
+	stats: false,
+	unique: true,
+};
 
 const globFiles = async (cwd, patterns) => {
 	const files = await globby(patterns, {
-		// Globs should work relative to the cwd value only (this should be the
-		// project directory that AVA is run in).
-		absolute: false,
-		braceExpansion: true,
-		caseSensitiveMatch: false,
+		...globOptions,
 		cwd,
-		dot: false,
-		expandDirectories: false,
-		extglob: true,
-		followSymbolicLinks: true,
-		gitignore: false,
-		globstar: true,
-		ignore: defaultIgnorePatterns,
-		baseNameMatch: false,
 		onlyFiles: true,
-		stats: false,
-		unique: true
 	});
 
 	// Return absolute file paths. This has the side-effect of normalizing paths
@@ -125,119 +103,114 @@ const globFiles = async (cwd, patterns) => {
 	return files.map(file => path.join(cwd, file));
 };
 
-async function findFiles({cwd, extensions, filePatterns}) {
-	return (await globFiles(cwd, filePatterns)).filter(file => hasExtension(extensions, file));
-}
+const globDirectoriesSync = (cwd, patterns) => {
+	const files = globbySync(patterns, {
+		...globOptions,
+		cwd,
+		onlyDirectories: true,
+	});
 
-exports.findFiles = findFiles;
+	// Return absolute file paths. This has the side-effect of normalizing paths
+	// on Windows.
+	return files.map(file => path.join(cwd, file));
+};
 
-async function findTests({cwd, extensions, filePatterns}) {
-	return (await findFiles({cwd, extensions, filePatterns})).filter(file => !path.basename(file).startsWith('_'));
+export async function findFiles({cwd, extensions, filePatterns}) {
+	const files = await globFiles(cwd, filePatterns);
+	return files.filter(file => hasExtension(extensions, file));
 }
 
-exports.findTests = findTests;
+export async function findTests({cwd, extensions, filePatterns}) {
+	const files = await findFiles({cwd, extensions, filePatterns});
+	return files.filter(file => !path.basename(file).startsWith('_'));
+}
 
-function getChokidarIgnorePatterns({ignoredByWatcherPatterns}) {
+export function getChokidarIgnorePatterns({ignoredByWatcherPatterns}) {
 	return [
 		...defaultIgnorePatterns.map(pattern => `${pattern}/**/*`),
-		...ignoredByWatcherPatterns.filter(pattern => !pattern.startsWith('!'))
+		...ignoredByWatcherPatterns.filter(pattern => !pattern.startsWith('!')),
 	];
 }
 
-exports.getChokidarIgnorePatterns = getChokidarIgnorePatterns;
-
-const matchingCache = new WeakMap();
-const processMatchingPatterns = input => {
-	let result = matchingCache.get(input);
-	if (!result) {
-		const ignore = [...defaultPicomatchIgnorePatterns];
-		const patterns = input.filter(pattern => {
-			if (pattern.startsWith('!')) {
-				// Unlike globby(), picomatch needs a complete pattern when ignoring directories.
-				ignore.push(pattern.slice(1), `${pattern.slice(1)}/**/*`);
-				return false;
+export function applyTestFileFilter({ // eslint-disable-line complexity
+	cwd,
+	expandDirectories = true,
+	filter,
+	providers = [],
+	testFiles,
+	treatFilterPatternsAsFiles = true,
+}) {
+	const {individualMatchers} = processMatchingPatterns(filter);
+	const normalizedFiles = testFiles.map(file => ({file, matcheable: normalizeFileForMatching(cwd, file)}));
+
+	const selected = new Set();
+	const unmatchedPatterns = new Set(individualMatchers.map(({pattern}) => pattern));
+
+	for (const {pattern, match} of individualMatchers) {
+		for (const {file, matcheable} of normalizedFiles) {
+			if (match(matcheable)) {
+				unmatchedPatterns.delete(pattern);
+				selected.add(file);
 			}
-
-			return true;
-		});
-
-		result = {
-			match: picomatch(patterns, {ignore}),
-			matchNoIgnore: picomatch(patterns)
-		};
-		matchingCache.set(input, result);
-	}
-
-	return result;
-};
-
-function matches(file, patterns) {
-	const {match} = processMatchingPatterns(patterns);
-	return match(file);
-}
-
-exports.matches = matches;
-
-const matchesIgnorePatterns = (file, patterns) => {
-	const {matchNoIgnore} = processMatchingPatterns(patterns);
-	return matchNoIgnore(file) || defaultMatchNoIgnore(file);
-};
-
-function normalizeFileForMatching(cwd, file) {
-	if (process.platform === 'win32') {
-		cwd = slash(cwd);
-		file = slash(file);
+		}
 	}
 
-	if (!cwd) { // TODO: Ensure tests provide an actual value.
-		return file;
-	}
+	if (expandDirectories && unmatchedPatterns.size > 0) {
+		const expansion = [];
+		for (const pattern of unmatchedPatterns) {
+			const directories = globDirectoriesSync(cwd, pattern);
+			if (directories.length > 0) {
+				unmatchedPatterns.delete(pattern);
+				expansion.push(directories);
+			}
+		}
 
-	// TODO: If `file` is outside `cwd` we can't normalize it. Need to figure
-	// out if that's a real-world scenario, but we may have to ensure the file
-	// isn't even selected.
-	if (!file.startsWith(cwd)) {
-		return file;
+		const directories = expansion.flat();
+		if (directories.length > 0) {
+			for (const file of testFiles) {
+				if (selected.has(file)) {
+					continue;
+				}
+
+				for (const dir of directories) {
+					if (file.startsWith(dir + path.sep)) { // eslint-disable-line max-depth
+						selected.add(file);
+					}
+				}
+			}
+		}
 	}
 
-	// Assume `cwd` does *not* end in a slash.
-	return file.slice(cwd.length + 1);
-}
-
-exports.normalizeFileForMatching = normalizeFileForMatching;
+	const ignoredFilterPatternFiles = [];
+	if (treatFilterPatternsAsFiles && unmatchedPatterns.size > 0) {
+		const providerExtensions = new Set(providers.flatMap(({main}) => main.extensions));
+		for (const pattern of unmatchedPatterns) {
+			const file = path.join(cwd, pattern);
+			try {
+				const stats = fs.statSync(file);
+				if (!stats.isFile()) {
+					continue;
+				}
+			} catch (error) {
+				if (error.code === 'ENOENT') {
+					continue;
+				}
+
+				throw error;
+			}
 
-function isHelperish(file) { // Assume file has been normalized already.
-	// File names starting with an underscore are deemed "helpers".
-	if (path.basename(file).startsWith('_')) {
-		return true;
-	}
+			if (
+				path.basename(file).startsWith('_')
+				|| providerExtensions.has(path.extname(file).slice(1))
+				|| file.split(path.sep).includes('node_modules')
+			) {
+				ignoredFilterPatternFiles.push(pattern);
+				continue;
+			}
 
-	// This function assumes the file has been normalized. If it couldn't be,
-	// don't check if it's got a parent directory that starts with an underscore.
-	// Deem it not a "helper".
-	if (path.isAbsolute(file)) {
-		return false;
+			selected.add(file);
+		}
 	}
 
-	// If the file has a parent directory that starts with only a single
-	// underscore, it's deemed a "helper".
-	return path.dirname(file).split('/').some(dir => /^_(?:$|[^_])/.test(dir));
+	return Object.assign([...selected], {ignoredFilterPatternFiles});
 }
-
-exports.isHelperish = isHelperish;
-
-function classify(file, {cwd, extensions, filePatterns, ignoredByWatcherPatterns}) {
-	file = normalizeFileForMatching(cwd, file);
-	return {
-		isIgnoredByWatcher: matchesIgnorePatterns(file, ignoredByWatcherPatterns),
-		isTest: hasExtension(extensions, file) && !isHelperish(file) && filePatterns.length > 0 && matches(file, filePatterns)
-	};
-}
-
-exports.classify = classify;
-
-function applyTestFileFilter({cwd, filter, testFiles}) {
-	return testFiles.filter(file => matches(normalizeFileForMatching(cwd, file), filter));
-}
-
-exports.applyTestFileFilter = applyTestFileFilter;

package/lib/{ipc-flow-control.js → ipc-flow-control.cjs}

@@ -1,3 +1,4 @@
+'use strict';
 function controlFlow(channel) {
 	let errored = false;
 	let deliverImmediately = true;

package/lib/is-ci.js

@@ -1,5 +1,7 @@
-const info = require('ci-info');
+import process from 'node:process';
+
+import info from 'ci-info';
 
 const {AVA_FORCE_CI} = process.env;
 
-module.exports = AVA_FORCE_CI === 'not-ci' ? false : AVA_FORCE_CI === 'ci' || info.isCI;
+export default AVA_FORCE_CI === 'not-ci' ? false : AVA_FORCE_CI === 'ci' || info.isCI;

package/lib/like-selector.js

@@ -1,17 +1,13 @@
-'use strict';
-function isLikeSelector(selector) {
-	return selector !== null &&
-		typeof selector === 'object' &&
-		Reflect.getPrototypeOf(selector) === Object.prototype &&
-		Reflect.ownKeys(selector).length > 0;
+export function isLikeSelector(selector) {
+	return selector !== null
+		&& typeof selector === 'object'
+		&& Reflect.getPrototypeOf(selector) === Object.prototype
+		&& Reflect.ownKeys(selector).length > 0;
 }
 
-exports.isLikeSelector = isLikeSelector;
+export const CIRCULAR_SELECTOR = new Error('Encountered a circular selector');
 
-const CIRCULAR_SELECTOR = new Error('Encountered a circular selector');
-exports.CIRCULAR_SELECTOR = CIRCULAR_SELECTOR;
-
-function selectComparable(lhs, selector, circular = new Set()) {
+export function selectComparable(lhs, selector, circular = new Set()) {
 	if (circular.has(selector)) {
 		throw CIRCULAR_SELECTOR;
 	}
@@ -33,5 +29,3 @@ function selectComparable(lhs, selector, circular = new Set()) {
 
 	return comparable;
 }
-
-exports.selectComparable = selectComparable;

package/lib/line-numbers.js

@@ -1,7 +1,4 @@
-'use strict';
-
-const picomatch = require('picomatch');
-const flatten = require('lodash/flatten');
+import picomatch from 'picomatch';
 
 const NUMBER_REGEX = /^\d+$/;
 const RANGE_REGEX = /^(?<startGroup>\d+)-(?<endGroup>\d+)$/;
@@ -17,10 +14,10 @@ const sortNumbersAscending = array => {
 
 const parseNumber = string => Number.parseInt(string, 10);
 const removeAllWhitespace = string => string.replace(/\s/g, '');
-const range = (start, end) => new Array(end - start + 1).fill(start).map((element, index) => element + index);
+const range = (start, end) => Array.from({length: end - start + 1}).fill(start).map((element, index) => element + index);
 
-const parseLineNumbers = suffix => sortNumbersAscending(distinctArray(flatten(
-	suffix.split(',').map(part => {
+const parseLineNumbers = suffix => sortNumbersAscending(distinctArray(
+	suffix.split(',').flatMap(part => {
 		if (NUMBER_REGEX.test(part)) {
 			return parseNumber(part);
 		}
@@ -34,10 +31,10 @@ const parseLineNumbers = suffix => sortNumbersAscending(distinctArray(flatten(
 		}
 
 		return range(start, end);
-	})
-)));
+	}),
+));
 
-function splitPatternAndLineNumbers(pattern) {
+export function splitPatternAndLineNumbers(pattern) {
 	const parts = pattern.split(DELIMITER);
 	if (parts.length === 1) {
 		return {pattern, lineNumbers: null};
@@ -51,14 +48,10 @@ function splitPatternAndLineNumbers(pattern) {
 	return {pattern: parts.join(DELIMITER), lineNumbers: parseLineNumbers(suffix)};
 }
 
-exports.splitPatternAndLineNumbers = splitPatternAndLineNumbers;
-
-function getApplicableLineNumbers(normalizedFilePath, filter) {
-	return sortNumbersAscending(distinctArray(flatten(
+export function getApplicableLineNumbers(normalizedFilePath, filter) {
+	return sortNumbersAscending(distinctArray(
 		filter
 			.filter(({pattern, lineNumbers}) => lineNumbers && picomatch.isMatch(normalizedFilePath, pattern))
-			.map(({lineNumbers}) => lineNumbers)
-	)));
+			.flatMap(({lineNumbers}) => lineNumbers),
+	));
 }
-
-exports.getApplicableLineNumbers = getApplicableLineNumbers;