ava 0.16.0 → 0.18.2

package/lib/babel-config.js

@@ -1,21 +1,20 @@
 'use strict';
-var path = require('path');
-var chalk = require('chalk');
-var figures = require('figures');
-var convertSourceMap = require('convert-source-map');
-var objectAssign = require('object-assign');
-var colors = require('./colors');
+const path = require('path');
+const chalk = require('chalk');
+const figures = require('figures');
+const convertSourceMap = require('convert-source-map');
+const colors = require('./colors');
 
 function validate(conf) {
 	if (conf === undefined || conf === null) {
 		conf = 'default';
 	}
 
-	// check for valid babel config shortcuts (can be either "default" or "inherit")
-	var isValidShortcut = conf === 'default' || conf === 'inherit';
+	// Check for valid babel config shortcuts (can be either `default` or `inherit`)
+	const isValidShortcut = conf === 'default' || conf === 'inherit';
 
 	if (!conf || (typeof conf === 'string' && !isValidShortcut)) {
-		var message = colors.error(figures.cross);
+		let message = colors.error(figures.cross);
 		message += ' Unexpected Babel configuration for AVA. ';
 		message += 'See ' + chalk.underline('https://github.com/avajs/ava#es2015-support') + ' for allowed values.';
 
@@ -25,74 +24,35 @@ function validate(conf) {
 	return conf;
 }
 
-function lazy(initFn) {
-	var initialized = false;
-	var value;
+function lazy(buildPreset) {
+	let preset;
 
-	return function () {
-		if (!initialized) {
-			initialized = true;
-			value = initFn();
+	return babel => {
+		if (!preset) {
+			preset = buildPreset(babel);
 		}
 
-		return value;
+		return preset;
 	};
 }
 
-var defaultPresets = lazy(function () {
-	return [
-		require('babel-preset-stage-2'),
-		require('babel-preset-es2015')
-	];
-});
+const stage4 = lazy(() => require('@ava/babel-preset-stage-4')());
 
-var rewritePlugin = lazy(function () {
-	var wrapListener = require('babel-plugin-detective/wrap-listener');
-
-	return wrapListener(rewriteBabelRuntimePaths, 'rewrite-runtime', {
-		generated: true,
-		require: true,
-		import: true
+function makeTransformTestFiles(powerAssert) {
+	return lazy(babel => {
+		return require('@ava/babel-preset-transform-test-files')(babel, {powerAssert});
 	});
-});
-
-function rewriteBabelRuntimePaths(path) {
-	var isBabelPath = /^babel-runtime[\\\/]?/.test(path.node.value);
-
-	if (path.isLiteral() && isBabelPath) {
-		path.node.value = require.resolve(path.node.value);
-	}
 }
 
-var espowerPlugin = lazy(function () {
-	var babel = require('babel-core');
-	var createEspowerPlugin = require('babel-plugin-espower/create');
-
-	// initialize power-assert
-	return createEspowerPlugin(babel, {
-		embedAst: true,
-		patterns: require('./enhance-assert').PATTERNS
-	});
-});
-
-var defaultPlugins = lazy(function () {
-	return [
-		espowerPlugin(),
-		require('babel-plugin-ava-throws-helper'),
-		rewritePlugin(),
-		require('babel-plugin-transform-runtime')
-	];
-});
-
-function build(babelConfig, filePath, code) {
+function build(babelConfig, powerAssert, filePath, code) {
 	babelConfig = validate(babelConfig);
 
-	var options;
+	let options;
 
 	if (babelConfig === 'default') {
 		options = {
 			babelrc: false,
-			presets: defaultPresets()
+			presets: [stage4]
 		};
 	} else if (babelConfig === 'inherit') {
 		options = {
@@ -103,29 +63,31 @@ function build(babelConfig, filePath, code) {
 			babelrc: false
 		};
 
-		objectAssign(options, babelConfig);
+		Object.assign(options, babelConfig);
 	}
 
-	var sourceMap = getSourceMap(filePath, code);
+	const sourceMap = getSourceMap(filePath, code);
 
-	objectAssign(options, {
+	Object.assign(options, {
 		inputSourceMap: sourceMap,
 		filename: filePath,
 		sourceMaps: true,
 		ast: false
 	});
 
-	options.plugins = (options.plugins || []).concat(defaultPlugins());
+	if (!options.presets) {
+		options.presets = [];
+	}
+	options.presets.push(makeTransformTestFiles(powerAssert));
 
 	return options;
 }
 
 function getSourceMap(filePath, code) {
-	var sourceMap = convertSourceMap.fromSource(code);
+	let sourceMap = convertSourceMap.fromSource(code);
 
 	if (!sourceMap) {
-		var dirPath = path.dirname(filePath);
-
+		const dirPath = path.dirname(filePath);
 		sourceMap = convertSourceMap.fromMapFileSource(code, dirPath);
 	}
 
@@ -137,10 +99,10 @@ function getSourceMap(filePath, code) {
 }
 
 module.exports = {
-	validate: validate,
-	build: build,
-	pluginPackages: [
-		require.resolve('babel-core/package.json'),
-		require.resolve('babel-plugin-espower/package.json')
+	validate,
+	build,
+	presetHashes: [
+		require('@ava/babel-preset-stage-4/package-hash'),
+		require('@ava/babel-preset-transform-test-files/package-hash')
 	]
 };

package/lib/beautify-stack.js

@@ -1,16 +1,13 @@
 'use strict';
-var StackUtils = require('stack-utils');
-var debug = require('debug')('ava');
+const StackUtils = require('stack-utils');
+const cleanStack = require('clean-stack');
+const debug = require('debug')('ava');
 
-function indent(str) {
-	return '    ' + str;
-}
-
-// ignore unimportant stack trace lines
-var ignoreStackLines = [];
+// Ignore unimportant stack trace lines
+let ignoreStackLines = [];
 
-var avaInternals = /\/ava\/(?:lib\/)?[\w-]+\.js:\d+:\d+\)?$/;
-var avaDependencies = /\/node_modules\/(?:bluebird|empower-core|(?:ava\/node_modules\/)?(?:babel-runtime|core-js))\//;
+const avaInternals = /\/ava\/(?:lib\/)?[\w-]+\.js:\d+:\d+\)?$/;
+const avaDependencies = /\/node_modules\/(?:bluebird|empower-core|(?:ava\/node_modules\/)?(?:babel-runtime|core-js))\//;
 
 if (!debug.enabled) {
 	ignoreStackLines = StackUtils.nodeInternals();
@@ -18,19 +15,23 @@ if (!debug.enabled) {
 	ignoreStackLines.push(avaDependencies);
 }
 
-var stackUtils = new StackUtils({internals: ignoreStackLines});
+const stackUtils = new StackUtils({internals: ignoreStackLines});
 
-module.exports = function (stack) {
+module.exports = stack => {
 	if (!stack) {
 		return '';
 	}
 
-	var title = stack.split('\n')[0];
-	var lines = stackUtils
+	// Workaround for https://github.com/tapjs/stack-utils/issues/14
+	// TODO: fix it in `stack-utils`
+	stack = cleanStack(stack);
+
+	const title = stack.split('\n')[0];
+	const lines = stackUtils
 		.clean(stack)
 		.split('\n')
-		.map(indent)
+		.map(x => `    ${x}`)
 		.join('\n');
 
-	return title + '\n' + lines;
+	return `${title}\n${lines}`;
 };

package/lib/caching-precompiler.js

@@ -1,96 +1,81 @@
 'use strict';
-var path = require('path');
-var fs = require('fs');
-var convertSourceMap = require('convert-source-map');
-var cachingTransform = require('caching-transform');
-var stripBom = require('strip-bom');
-var md5Hex = require('md5-hex');
-var packageHash = require('package-hash');
-var babelConfigHelper = require('./babel-config');
-
-function CachingPrecompiler(cacheDirPath, babelConfig) {
-	if (!(this instanceof CachingPrecompiler)) {
-		throw new TypeError('Class constructor CachingPrecompiler cannot be invoked without \'new\'');
+const path = require('path');
+const fs = require('fs');
+const convertSourceMap = require('convert-source-map');
+const cachingTransform = require('caching-transform');
+const packageHash = require('package-hash');
+const stripBomBuf = require('strip-bom-buf');
+const autoBind = require('auto-bind');
+const md5Hex = require('md5-hex');
+const babelConfigHelper = require('./babel-config');
+
+class CachingPrecompiler {
+	constructor(options) {
+		autoBind(this);
+
+		options = options || {};
+
+		this.babelConfig = babelConfigHelper.validate(options.babel);
+		this.cacheDirPath = options.path;
+		this.powerAssert = Boolean(options.powerAssert);
+		this.fileHashes = {};
+		this.transform = this._createTransform();
 	}
+	precompileFile(filePath) {
+		if (!this.fileHashes[filePath]) {
+			const source = stripBomBuf(fs.readFileSync(filePath));
+			this.transform(source, filePath);
+		}
 
-	this.babelConfig = babelConfigHelper.validate(babelConfig);
-	this.cacheDirPath = cacheDirPath;
-	this.fileHashes = {};
-
-	Object.keys(CachingPrecompiler.prototype).forEach(function (name) {
-		this[name] = this[name].bind(this);
-	}, this);
-
-	this.transform = this._createTransform();
-}
-
-module.exports = CachingPrecompiler;
-
-CachingPrecompiler.prototype.precompileFile = function (filePath) {
-	if (!this.fileHashes[filePath]) {
-		var source = stripBom(fs.readFileSync(filePath));
-
-		this.transform(source, filePath);
+		return this.fileHashes[filePath];
 	}
+	// Conditionally called by caching-transform when precompiling is required
+	_init() {
+		this.babel = require('babel-core');
+		return this._transform;
+	}
+	_transform(code, filePath, hash) {
+		code = code.toString();
 
-	return this.fileHashes[filePath];
-};
-
-// conditionally called by caching-transform when precompiling is required
-CachingPrecompiler.prototype._factory = function () {
-	this._init();
-
-	return this._transform;
-};
-
-CachingPrecompiler.prototype._init = function () {
-	this.babel = require('babel-core');
-};
-
-CachingPrecompiler.prototype._transform = function (code, filePath, hash) {
-	code = code.toString();
-
-	var options = babelConfigHelper.build(this.babelConfig, filePath, code);
-	var result = this.babel.transform(code, options);
-
-	// save source map
-	var mapPath = path.join(this.cacheDirPath, hash + '.js.map');
-	fs.writeFileSync(mapPath, JSON.stringify(result.map));
-
-	// When loading the test file, test workers intercept the require call and
-	// load the cached code instead. Libraries like nyc may also be intercepting
-	// require calls, however they won't know that different code was loaded.
-	// They may then attempt to resolve a source map from the original file
-	// location.
-	//
-	// Add a source map file comment to the cached code. The file path is
-	// relative from the directory of the original file to where the source map
-	// is cached. This will allow the source map to be resolved.
-	var dirPath = path.dirname(filePath);
-	var relativeMapPath = path.relative(dirPath, mapPath);
-	var comment = convertSourceMap.generateMapFileComment(relativeMapPath);
-
-	return result.code + '\n' + comment;
-};
+		const options = babelConfigHelper.build(this.babelConfig, this.powerAssert, filePath, code);
+		const result = this.babel.transform(code, options);
 
-CachingPrecompiler.prototype._createTransform = function () {
-	var salt = packageHash.sync(
-		[require.resolve('../package.json')].concat(babelConfigHelper.pluginPackages),
-		JSON.stringify(this.babelConfig)
-	);
+		// Save source map
+		const mapPath = path.join(this.cacheDirPath, `${hash}.js.map`);
+		fs.writeFileSync(mapPath, JSON.stringify(result.map));
 
-	return cachingTransform({
-		factory: this._factory,
-		cacheDir: this.cacheDirPath,
-		hash: this._generateHash,
-		salt: salt,
-		ext: '.js'
-	});
-};
+		// Append source map comment to transformed code
+		// So that other libraries (like nyc) can find the source map
+		const dirPath = path.dirname(filePath);
+		const relativeMapPath = path.relative(dirPath, mapPath);
+		const comment = convertSourceMap.generateMapFileComment(relativeMapPath);
 
-CachingPrecompiler.prototype._generateHash = function (code, filePath, salt) {
-	var hash = md5Hex([code, filePath, salt]);
-	this.fileHashes[filePath] = hash;
+		return `${result.code}\n${comment}`;
+	}
+	_createTransform() {
+		const salt = packageHash.sync([
+			require.resolve('../package.json'),
+			require.resolve('babel-core/package.json')
+		], {
+			babelConfig: this.babelConfig,
+			majorNodeVersion: process.version.split('.')[0],
+			powerAssert: this.powerAssert,
+			presetHashes: babelConfigHelper.presetHashes
+		});
+
+		return cachingTransform({
+			factory: this._init,
+			cacheDir: this.cacheDirPath,
+			hash: this._generateHash,
+			salt,
+			ext: '.js'
+		});
+	}
+	_generateHash(code, filePath, salt) {
+		const hash = md5Hex([code, filePath, salt]);
+		this.fileHashes[filePath] = hash;
+		return hash;
+	}
+}
 
-	return hash;
-};
+module.exports = CachingPrecompiler;

package/lib/cli.js

@@ -0,0 +1,181 @@
+'use strict';
+const path = require('path');
+const updateNotifier = require('update-notifier');
+const figures = require('figures');
+const arrify = require('arrify');
+const meow = require('meow');
+const Promise = require('bluebird');
+const pkgConf = require('pkg-conf');
+const isCi = require('is-ci');
+const hasFlag = require('has-flag');
+const Api = require('../api');
+const colors = require('./colors');
+const VerboseReporter = require('./reporters/verbose');
+const MiniReporter = require('./reporters/mini');
+const TapReporter = require('./reporters/tap');
+const Logger = require('./logger');
+const Watcher = require('./watcher');
+const babelConfig = require('./babel-config');
+
+// Bluebird specific
+Promise.longStackTraces();
+
+exports.run = () => {
+	const conf = pkgConf.sync('ava');
+
+	const filepath = pkgConf.filepath(conf);
+	const projectDir = filepath === null ? process.cwd() : path.dirname(filepath);
+
+	const cli = meow(`
+		Usage
+		  ava [<file|directory|glob> ...]
+
+		Options
+		  --init                  Add AVA to your project
+		  --fail-fast             Stop after first test failure
+		  --serial, -s            Run tests serially
+		  --tap, -t               Generate TAP output
+		  --verbose, -v           Enable verbose output
+		  --no-cache              Disable the transpiler cache
+		  --no-power-assert       Disable Power Assert
+		  --no-color              Disable color output
+		  --match, -m             Only run tests with matching title (Can be repeated)
+		  --watch, -w             Re-run tests when tests and source files change
+		  --timeout, -T           Set global timeout
+		  --concurrency, -c       Maximum number of test files running at the same time (EXPERIMENTAL)
+		  --update-snapshots, -u  Update snapshots
+
+		Examples
+		  ava
+		  ava test.js test2.js
+		  ava test-*.js
+		  ava test
+		  ava --init
+		  ava --init foo.js
+
+		Default patterns when no arguments:
+		test.js test-*.js test/**/*.js **/__tests__/**/*.js **/*.test.js
+	`, {
+		string: [
+			'_',
+			'match',
+			'timeout',
+			'concurrency'
+		],
+		boolean: [
+			'init',
+			'fail-fast',
+			'serial',
+			'tap',
+			'verbose',
+			'watch',
+			'update-snapshots',
+			'color'
+		],
+		default: Object.assign({color: true}, conf),
+		alias: {
+			t: 'tap',
+			v: 'verbose',
+			s: 'serial',
+			m: 'match',
+			w: 'watch',
+			T: 'timeout',
+			c: 'concurrency',
+			u: 'update-snapshots'
+		}
+	});
+
+	updateNotifier({pkg: cli.pkg}).notify();
+
+	if (cli.flags.init) {
+		require('ava-init')();
+		return;
+	}
+
+	if (
+		((hasFlag('--watch') || hasFlag('-w')) && (hasFlag('--tap') || hasFlag('-t'))) ||
+		(conf.watch && conf.tap)
+	) {
+		throw new Error(colors.error(figures.cross) + ' The TAP reporter is not available when using watch mode.');
+	}
+
+	if ((hasFlag('--watch') || hasFlag('-w')) && isCi) {
+		throw new Error(colors.error(figures.cross) + ' Watch mode is not available in CI, as it prevents AVA from terminating.');
+	}
+
+	if (hasFlag('--require') || hasFlag('-r')) {
+		throw new Error(colors.error(figures.cross) + ' The --require and -r flags are deprecated. Requirements should be configured in package.json - see documentation.');
+	}
+
+	const api = new Api({
+		failFast: cli.flags.failFast,
+		serial: cli.flags.serial,
+		require: arrify(conf.require),
+		cacheEnabled: cli.flags.cache !== false,
+		powerAssert: cli.flags.powerAssert !== false,
+		explicitTitles: cli.flags.watch,
+		match: arrify(cli.flags.match),
+		babelConfig: babelConfig.validate(conf.babel),
+		resolveTestsFrom: cli.input.length === 0 ? projectDir : process.cwd(),
+		projectDir,
+		timeout: cli.flags.timeout,
+		concurrency: cli.flags.concurrency ? parseInt(cli.flags.concurrency, 10) : 0,
+		updateSnapshots: cli.flags.updateSnapshots,
+		color: cli.flags.color
+	});
+
+	let reporter;
+
+	if (cli.flags.tap && !cli.flags.watch) {
+		reporter = new TapReporter();
+	} else if (cli.flags.verbose || isCi) {
+		reporter = new VerboseReporter({color: cli.flags.color});
+	} else {
+		reporter = new MiniReporter({color: cli.flags.color, watching: cli.flags.watch});
+	}
+
+	reporter.api = api;
+	const logger = new Logger(reporter);
+
+	logger.start();
+
+	api.on('test-run', runStatus => {
+		reporter.api = runStatus;
+		runStatus.on('test', logger.test);
+		runStatus.on('error', logger.unhandledError);
+
+		runStatus.on('stdout', logger.stdout);
+		runStatus.on('stderr', logger.stderr);
+	});
+
+	const files = cli.input.length ? cli.input : arrify(conf.files);
+
+	if (cli.flags.watch) {
+		try {
+			const watcher = new Watcher(logger, api, files, arrify(conf.source));
+			watcher.observeStdin(process.stdin);
+		} catch (err) {
+			if (err.name === 'AvaError') {
+				// An AvaError may be thrown if `chokidar` is not installed. Log it nicely.
+				console.error(`  ${colors.error(figures.cross)} ${err.message}`);
+				logger.exit(1);
+			} else {
+				// Rethrow so it becomes an uncaught exception
+				throw err;
+			}
+		}
+	} else {
+		api.run(files)
+			.then(runStatus => {
+				logger.finish(runStatus);
+				logger.exit(runStatus.failCount > 0 || runStatus.rejectionCount > 0 || runStatus.exceptionCount > 0 ? 1 : 0);
+			})
+			.catch(err => {
+				// Don't swallow exceptions. Note that any expected error should already
+				// have been logged.
+				setImmediate(() => {
+					throw err;
+				});
+			});
+	}
+};

package/lib/code-excerpt.js

@@ -0,0 +1,57 @@
+'use strict';
+const fs = require('fs');
+const equalLength = require('equal-length');
+const codeExcerpt = require('code-excerpt');
+const truncate = require('cli-truncate');
+const chalk = require('chalk');
+
+const formatLineNumber = (lineNumber, maxLineNumber) =>
+	' '.repeat(Math.max(0, String(maxLineNumber).length - String(lineNumber).length)) + lineNumber;
+
+module.exports = (source, options) => {
+	if (!source.isWithinProject || source.isDependency) {
+		return null;
+	}
+
+	const file = source.file;
+	const line = source.line;
+
+	options = options || {};
+	const maxWidth = options.maxWidth || 80;
+
+	let contents;
+	try {
+		contents = fs.readFileSync(file, 'utf8');
+	} catch (err) {
+		return null;
+	}
+
+	const excerpt = codeExcerpt(contents, line, {around: 1});
+	if (!excerpt) {
+		return null;
+	}
+
+	const lines = excerpt.map(item => ({
+		line: item.line,
+		value: truncate(item.value, maxWidth - String(line).length - 5)
+	}));
+
+	const joinedLines = lines.map(line => line.value).join('\n');
+	const extendedLines = equalLength(joinedLines).split('\n');
+
+	return lines
+		.map((item, index) => ({
+			line: item.line,
+			value: extendedLines[index]
+		}))
+		.map(item => {
+			const isErrorSource = item.line === line;
+
+			const lineNumber = formatLineNumber(item.line, line) + ':';
+			const coloredLineNumber = isErrorSource ? lineNumber : chalk.grey(lineNumber);
+			const result = ` ${coloredLineNumber} ${item.value}`;
+
+			return isErrorSource ? chalk.bgRed(result) : result;
+		})
+		.join('\n');
+};

package/lib/colors.js

@@ -1,11 +1,15 @@
 'use strict';
-var chalk = require('chalk');
+const chalk = require('chalk');
 
 module.exports = {
+	title: chalk.bold.white,
 	error: chalk.red,
 	skip: chalk.yellow,
 	todo: chalk.blue,
 	pass: chalk.green,
 	duration: chalk.gray.dim,
-	stack: chalk.red
+	errorSource: chalk.gray,
+	errorStack: chalk.gray,
+	stack: chalk.red,
+	information: chalk.magenta
 };