ava 4.0.0-alpha.1 → 4.0.1

package/lib/create-chain.js

@@ -1,4 +1,3 @@
-'use strict';
 const chainRegistry = new WeakMap();
 
 function startChain(name, call, defaults) {
@@ -57,7 +56,7 @@ function createHookChain(hook, isAfterHook) {
 	return hook;
 }
 
-function createChain(fn, defaults, meta) {
+export default function createChain(fn, defaults, meta) {
 	// Test chaining rules:
 	// * `serial` must come at the start
 	// * `only` and `skip` must come at the end
@@ -92,9 +91,38 @@ function createChain(fn, defaults, meta) {
 	root.todo = startChain('test.todo', fn, {...defaults, type: 'test', todo: true});
 	root.serial.todo = startChain('test.serial.todo', fn, {...defaults, serial: true, type: 'test', todo: true});
 
+	root.macro = options => {
+		if (typeof options === 'function') {
+			return Object.freeze({exec: options});
+		}
+
+		return Object.freeze({exec: options.exec, title: options.title});
+	};
+
 	root.meta = meta;
 
+	// Our type definition uses ESM syntax; when using CJS with VSCode, the
+	// auto-completion assumes the root is accessed through `require('ava').default`.
+	// Placate VSCode by adding a mostly hidden default property on the root.
+	// This is available through both CJS and ESM imports. We use a proxy so that
+	// we don't end up with root.default.default.default chains.
+	Object.defineProperty(root, 'default', {
+		configurable: false,
+		enumerable: false,
+		writable: false,
+		value: new Proxy(root, {
+			apply(target, thisArg, argumentsList) {
+				target.apply(thisArg, argumentsList);
+			},
+			get(target, prop) {
+				if (prop === 'default') {
+					throw new TypeError('Cannot access default.default');
+				}
+
+				return target[prop];
+			},
+		}),
+	});
+
 	return root;
 }
-
-module.exports = createChain;

package/lib/environment-variables.js

@@ -1,5 +1,4 @@
-'use strict';
-function validateEnvironmentVariables(environmentVariables) {
+export default function validateEnvironmentVariables(environmentVariables) {
 	if (!environmentVariables) {
 		return {};
 	}
@@ -12,5 +11,3 @@ function validateEnvironmentVariables(environmentVariables) {
 
 	return environmentVariables;
 }
-
-module.exports = validateEnvironmentVariables;

package/lib/eslint-plugin-helper-worker.js

@@ -1,33 +1,23 @@
-'use strict';
-const v8 = require('v8');
-const {parentPort, workerData} = require('worker_threads');
+import v8 from 'node:v8';
+import {parentPort, workerData} from 'node:worker_threads';
 
-const {normalizeGlobs} = require('./globs');
-const normalizeExtensions = require('./extensions');
-const {loadConfig} = require('./load-config');
-const providerManager = require('./provider-manager');
+import normalizeExtensions from './extensions.js';
+import {normalizeGlobs} from './globs.js';
+import {loadConfig} from './load-config.js';
+import providerManager from './provider-manager.js';
 
 const MAX_DATA_LENGTH_EXCLUSIVE = 100 * 1024; // Allocate 100 KiB to exchange globs.
 
 const configCache = new Map();
 
-const collectProviders = ({conf, projectDir}) => {
+const collectProviders = async ({conf, projectDir}) => {
 	const providers = [];
-	if (Reflect.has(conf, 'babel')) {
-		const {level, main} = providerManager.babel(projectDir);
-		providers.push({
-			level,
-			main: main({config: conf.babel}),
-			type: 'babel'
-		});
-	}
-
 	if (Reflect.has(conf, 'typescript')) {
-		const {level, main} = providerManager.typescript(projectDir);
+		const {level, main} = await providerManager.typescript(projectDir);
 		providers.push({
 			level,
 			main: main({config: conf.typescript}),
-			type: 'typescript'
+			type: 'typescript',
 		});
 	}
 
@@ -35,24 +25,24 @@ const collectProviders = ({conf, projectDir}) => {
 };
 
 const buildGlobs = ({conf, providers, projectDir, overrideExtensions, overrideFiles}) => {
-	const extensions = overrideExtensions ?
-		normalizeExtensions(overrideExtensions) :
-		normalizeExtensions(conf.extensions, providers);
+	const extensions = overrideExtensions
+		? normalizeExtensions(overrideExtensions)
+		: normalizeExtensions(conf.extensions, providers);
 
 	return {
 		cwd: projectDir,
 		...normalizeGlobs({
 			extensions,
 			files: overrideFiles ? overrideFiles : conf.files,
-			providers
-		})
+			providers,
+		}),
 	};
 };
 
 const resolveGlobs = async (projectDir, overrideExtensions, overrideFiles) => {
 	if (!configCache.has(projectDir)) {
-		configCache.set(projectDir, loadConfig({resolveFrom: projectDir}).then(conf => { // eslint-disable-line promise/prefer-await-to-then
-			const providers = collectProviders({conf, projectDir});
+		configCache.set(projectDir, loadConfig({resolveFrom: projectDir}).then(async conf => {
+			const providers = await collectProviders({conf, projectDir});
 			return {conf, providers};
 		}));
 	}

package/lib/extensions.js

@@ -1,4 +1,4 @@
-module.exports = (configuredExtensions, providers = []) => {
+export default function resolveExtensions(configuredExtensions, providers = []) {
 	// Combine all extensions possible for testing. Remove duplicate extensions.
 	const duplicates = new Set();
 	const seen = new Set();
@@ -43,4 +43,4 @@ module.exports = (configuredExtensions, providers = []) => {
 	}
 
 	return [...seen];
-};
+}

package/lib/fork.js

@@ -1,96 +1,58 @@
-'use strict';
-const {Worker} = require('worker_threads');
-const childProcess = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const Emittery = require('emittery');
-const {controlFlow} = require('./ipc-flow-control');
-
-if (fs.realpathSync(__filename) !== __filename) {
-	console.warn('WARNING: `npm link ava` and the `--preserve-symlink` flag are incompatible. We have detected that AVA is linked via `npm link`, and that you are using either an early version of Node 6, or the `--preserve-symlink` flag. This breaks AVA. You should upgrade to Node 6.2.0+, avoid the `--preserve-symlink` flag, or avoid using `npm link ava`.');
-}
-
-// In case the test file imports a different AVA install,
-// the presence of this variable allows it to require this one instead
-const AVA_PATH = path.resolve(__dirname, '..');
-const WORKER_PATH = require.resolve('./worker/base.js');
-
-class SharedWorkerChannel extends Emittery {
-	constructor({channelId, filename, initialData}, sendToFork) {
-		super();
-
-		this.id = channelId;
-		this.filename = filename;
-		this.initialData = initialData;
-		this.sendToFork = sendToFork;
-	}
-
-	signalReady() {
-		this.sendToFork({
-			type: 'shared-worker-ready',
-			channelId: this.id
-		});
-	}
+import childProcess from 'node:child_process';
+import process from 'node:process';
+import {fileURLToPath} from 'node:url';
+import {Worker} from 'node:worker_threads';
 
-	signalError() {
-		this.sendToFork({
-			type: 'shared-worker-error',
-			channelId: this.id
-		});
-	}
+import Emittery from 'emittery';
+import {pEvent} from 'p-event';
 
-	emitMessage({messageId, replyTo, serializedData}) {
-		this.emit('message', {
-			messageId,
-			replyTo,
-			serializedData
-		});
-	}
+import {controlFlow} from './ipc-flow-control.cjs';
+import serializeError from './serialize-error.js';
 
-	forwardMessageToFork({messageId, replyTo, serializedData}) {
-		this.sendToFork({
-			type: 'shared-worker-message',
-			channelId: this.id,
-			messageId,
-			replyTo,
-			serializedData
-		});
-	}
+let workerPath = new URL('worker/base.js', import.meta.url);
+export function _testOnlyReplaceWorkerPath(replacement) {
+	workerPath = replacement;
 }
 
-let forkCounter = 0;
+const additionalExecArgv = ['--enable-source-maps'];
 
 const createWorker = (options, execArgv) => {
 	let worker;
 	let postMessage;
 	let close;
 	if (options.workerThreads) {
-		worker = new Worker(WORKER_PATH, {
+		worker = new Worker(workerPath, {
 			argv: options.workerArgv,
-			env: {NODE_ENV: 'test', ...process.env, ...options.environmentVariables, AVA_PATH},
-			execArgv,
+			env: {NODE_ENV: 'test', ...process.env, ...options.environmentVariables},
+			execArgv: [...execArgv, ...additionalExecArgv],
 			workerData: {
-				options
+				options,
 			},
 			trackUnmanagedFds: true,
 			stdin: true,
 			stdout: true,
-			stderr: true
+			stderr: true,
 		});
 		postMessage = worker.postMessage.bind(worker);
+
+		// Ensure we've seen this event before we terminate the worker thread, as a
+		// workaround for https://github.com/nodejs/node/issues/38418.
+		const starting = pEvent(worker, 'message', ({ava}) => ava && ava.type === 'starting');
+
 		close = async () => {
 			try {
+				await starting;
 				await worker.terminate();
 			} finally {
 				// No-op
 			}
 		};
 	} else {
-		worker = childProcess.fork(WORKER_PATH, options.workerArgv, {
+		worker = childProcess.fork(fileURLToPath(workerPath), options.workerArgv, {
 			cwd: options.projectDir,
 			silent: true,
-			env: {NODE_ENV: 'test', ...process.env, ...options.environmentVariables, AVA_PATH},
-			execArgv
+			env: {NODE_ENV: 'test', ...process.env, ...options.environmentVariables},
+			execArgv: [...execArgv, ...additionalExecArgv],
 		});
 		postMessage = controlFlow(worker);
 		close = async () => worker.kill();
@@ -99,15 +61,11 @@ const createWorker = (options, execArgv) => {
 	return {
 		worker,
 		postMessage,
-		close
+		close,
 	};
 };
 
-module.exports = (file, options, execArgv = process.execArgv) => {
-	// TODO: this can be changed to use `threadId` when using worker_threads
-	const forkId = `fork/${++forkCounter}`;
-	const sharedWorkerChannels = new Map();
-
+export default function loadFork(file, options, execArgv = process.execArgv) {
 	let finished = false;
 
 	const emitter = new Emittery();
@@ -120,8 +78,7 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 	options = {
 		baseDir: process.cwd(),
 		file,
-		forkId,
-		...options
+		...options,
 	};
 
 	const {worker, postMessage, close} = createWorker(options, execArgv);
@@ -155,17 +112,19 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 				case 'ready-for-options':
 					send({type: 'options', options});
 					break;
-
 				case 'shared-worker-connect': {
-					const channel = new SharedWorkerChannel(message.ava, send);
-					sharedWorkerChannels.set(channel.id, channel);
-					emitter.emit('connectSharedWorker', channel);
+					const {channelId, filename, initialData, port} = message.ava;
+					emitter.emit('connectSharedWorker', {
+						filename,
+						initialData,
+						port,
+						signalError() {
+							send({type: 'shared-worker-error', channelId});
+						},
+					});
 					break;
 				}
 
-				case 'shared-worker-message':
-					sharedWorkerChannels.get(message.ava.channelId).emitMessage(message.ava);
-					break;
 				case 'ping':
 					send({type: 'pong'});
 					break;
@@ -175,7 +134,7 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 		});
 
 		worker.on('error', error => {
-			emitStateChange({type: 'worker-failed', err: error});
+			emitStateChange({type: 'worker-failed', err: serializeError('Worker error', false, error, file)});
 			finish();
 		});
 
@@ -196,7 +155,7 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 
 	return {
 		file,
-		forkId,
+		threadId: worker.threadId,
 		promise,
 
 		exit() {
@@ -214,6 +173,6 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 
 		onStateChange(listener) {
 			return emitter.on('stateChange', listener);
-		}
+		},
 	};
-};
+}

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;