ava 0.15.0 → 0.17.0

package/lib/babel-config.js

@@ -0,0 +1,152 @@
+'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 semver = require('semver');
+var 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';
+
+	if (!conf || (typeof conf === 'string' && !isValidShortcut)) {
+		var 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.';
+
+		throw new Error(message);
+	}
+
+	return conf;
+}
+
+function lazy(initFn) {
+	var initialized = false;
+	var value;
+
+	return function () {
+		if (!initialized) {
+			initialized = true;
+			value = initFn();
+		}
+
+		return value;
+	};
+}
+
+var defaultPresets = lazy(function () {
+	var esPreset = semver.satisfies(process.version, '>=4') ?
+		'babel-preset-es2015-node4' :
+		'babel-preset-es2015';
+
+	return [
+		require('babel-preset-stage-2'),
+		require(esPreset) // eslint-disable-line import/no-dynamic-require
+	];
+});
+
+var rewritePlugin = lazy(function () {
+	var wrapListener = require('babel-plugin-detective/wrap-listener');
+
+	return wrapListener(rewriteBabelRuntimePaths, 'rewrite-runtime', {
+		generated: true,
+		require: true,
+		import: true
+	});
+});
+
+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 [
+		require('babel-plugin-ava-throws-helper'),
+		rewritePlugin(),
+		require('babel-plugin-transform-runtime')
+	];
+});
+
+function build(babelConfig, powerAssert, filePath, code) {
+	babelConfig = validate(babelConfig);
+
+	var options;
+
+	if (babelConfig === 'default') {
+		options = {
+			babelrc: false,
+			presets: defaultPresets()
+		};
+	} else if (babelConfig === 'inherit') {
+		options = {
+			babelrc: true
+		};
+	} else {
+		options = {
+			babelrc: false
+		};
+
+		objectAssign(options, babelConfig);
+	}
+
+	var sourceMap = getSourceMap(filePath, code);
+
+	objectAssign(options, {
+		inputSourceMap: sourceMap,
+		filename: filePath,
+		sourceMaps: true,
+		ast: false
+	});
+
+	options.plugins = (options.plugins || [])
+		.concat(powerAssert ? espowerPlugin() : [])
+		.concat(defaultPlugins());
+
+	return options;
+}
+
+function getSourceMap(filePath, code) {
+	var sourceMap = convertSourceMap.fromSource(code);
+
+	if (!sourceMap) {
+		var dirPath = path.dirname(filePath);
+
+		sourceMap = convertSourceMap.fromMapFileSource(code, dirPath);
+	}
+
+	if (sourceMap) {
+		sourceMap = sourceMap.toObject();
+	}
+
+	return sourceMap;
+}
+
+module.exports = {
+	validate: validate,
+	build: build,
+	pluginPackages: [
+		require.resolve('babel-core/package.json'),
+		require.resolve('babel-plugin-espower/package.json')
+	]
+};

package/lib/beautify-stack.js

@@ -2,6 +2,25 @@
 var StackUtils = require('stack-utils');
 var debug = require('debug')('ava');
 
+//-----------
+// embedded `clean-stack` module (because it requires Node.js 4)
+var extractPathRegex = /\s+at.*(?:\(|\s)(.*)\)?/;
+var pathRegex = /^(?:(?:(?:node|(?:internal\/[\w/]*|.*node_modules\/babel-polyfill\/.*)?\w+)\.js:\d+:\d+)|native)/;
+
+var cleanStack = function (stack) {
+	return stack.replace(/\\/g, '/').split('\n').filter(function (x) {
+		var pathMatches = x.match(extractPathRegex);
+		if (pathMatches === null || !pathMatches[1]) {
+			return true;
+		}
+
+		return !pathRegex.test(pathMatches[1]);
+	}).filter(function (x) {
+		return x.trim() !== '';
+	}).join('\n');
+};
+//-----------
+
 function indent(str) {
 	return '    ' + str;
 }
@@ -25,6 +44,10 @@ module.exports = function (stack) {
 		return '';
 	}
 
+	// workaround for https://github.com/tapjs/stack-utils/issues/14
+	// TODO: fix it in `stack-utils`
+	stack = cleanStack(stack);
+
 	var title = stack.split('\n')[0];
 	var lines = stackUtils
 		.clean(stack)

package/lib/caching-precompiler.js

@@ -3,24 +3,25 @@ var path = require('path');
 var fs = require('fs');
 var convertSourceMap = require('convert-source-map');
 var cachingTransform = require('caching-transform');
-var objectAssign = require('object-assign');
+var packageHash = require('package-hash');
 var stripBom = require('strip-bom');
+var autoBind = require('auto-bind');
 var md5Hex = require('md5-hex');
-var packageHash = require('package-hash');
-var enhanceAssert = require('./enhance-assert');
+var babelConfigHelper = require('./babel-config');
 
-function CachingPrecompiler(cacheDirPath, babelConfig) {
+function CachingPrecompiler(options) {
 	if (!(this instanceof CachingPrecompiler)) {
 		throw new TypeError('Class constructor CachingPrecompiler cannot be invoked without \'new\'');
 	}
 
-	this.babelConfig = babelConfig || 'default';
-	this.cacheDirPath = cacheDirPath;
-	this.fileHashes = {};
+	autoBind(this);
 
-	Object.keys(CachingPrecompiler.prototype).forEach(function (name) {
-		this[name] = this[name].bind(this);
-	}, this);
+	options = options || {};
+
+	this.babelConfig = babelConfigHelper.validate(options.babel);
+	this.cacheDirPath = options.path;
+	this.powerAssert = Boolean(options.powerAssert);
+	this.fileHashes = {};
 
 	this.transform = this._createTransform();
 }
@@ -38,52 +39,24 @@ CachingPrecompiler.prototype.precompileFile = function (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');
 
-	this.defaultPresets = [
-		require('babel-preset-stage-2'),
-		require('babel-preset-es2015')
-	];
-
-	var transformRuntime = require('babel-plugin-transform-runtime');
-	var throwsHelper = require('babel-plugin-ava-throws-helper');
-	var rewriteBabelPaths = this._createRewritePlugin();
-	var powerAssert = this._createEspowerPlugin();
-
-	this.defaultPlugins = [
-		powerAssert,
-		throwsHelper,
-		rewriteBabelPaths,
-		transformRuntime
-	];
+	return this._transform;
 };
 
 CachingPrecompiler.prototype._transform = function (code, filePath, hash) {
 	code = code.toString();
 
-	var options = this._buildOptions(filePath, code);
+	var options = babelConfigHelper.build(this.babelConfig, this.powerAssert, 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.
+	// append source map comment to transformed code
+	// so that other libraries (like nyc) can find the source map
 	var dirPath = path.dirname(filePath);
 	var relativeMapPath = path.relative(dirPath, mapPath);
 	var comment = convertSourceMap.generateMapFileComment(relativeMapPath);
@@ -91,83 +64,19 @@ CachingPrecompiler.prototype._transform = function (code, filePath, hash) {
 	return result.code + '\n' + comment;
 };
 
-CachingPrecompiler.prototype._buildOptions = function (filePath, code) {
-	var options = {babelrc: false};
-
-	if (this.babelConfig === 'default') {
-		objectAssign(options, {presets: this.defaultPresets});
-	} else if (this.babelConfig === 'inherit') {
-		objectAssign(options, {babelrc: true});
-	} else {
-		objectAssign(options, this.babelConfig);
-	}
-
-	var sourceMap = this._getSourceMap(filePath, code);
-
-	objectAssign(options, {
-		inputSourceMap: sourceMap,
-		filename: filePath,
-		sourceMaps: true,
-		ast: false
-	});
-
-	options.plugins = (options.plugins || []).concat(this.defaultPlugins);
-
-	return options;
-};
-
-CachingPrecompiler.prototype._getSourceMap = function (filePath, code) {
-	var sourceMap = convertSourceMap.fromSource(code);
-
-	if (!sourceMap) {
-		var dirPath = path.dirname(filePath);
-
-		sourceMap = convertSourceMap.fromMapFileSource(code, dirPath);
-	}
-
-	if (sourceMap) {
-		sourceMap = sourceMap.toObject();
-	}
-
-	return sourceMap;
-};
-
-CachingPrecompiler.prototype._createRewritePlugin = function () {
-	var wrapListener = require('babel-plugin-detective/wrap-listener');
-
-	return wrapListener(this._rewriteBabelRuntimePaths, 'rewrite-runtime', {
-		generated: true,
-		require: true,
-		import: true
-	});
-};
-
-CachingPrecompiler.prototype._rewriteBabelRuntimePaths = function (path) {
-	var isBabelPath = /^babel-runtime[\\\/]?/.test(path.node.value);
-
-	if (path.isLiteral() && isBabelPath) {
-		path.node.value = require.resolve(path.node.value);
-	}
-};
-
-CachingPrecompiler.prototype._createEspowerPlugin = function () {
-	var createEspowerPlugin = require('babel-plugin-espower/create');
+CachingPrecompiler.prototype._createTransform = function () {
+	var pluginPackages = babelConfigHelper.pluginPackages;
+	var avaPackage = require.resolve('../package.json');
+	var packages = [avaPackage].concat(pluginPackages);
 
-	// initialize power-assert
-	return createEspowerPlugin(this.babel, {
-		patterns: enhanceAssert.PATTERNS
-	});
-};
+	var majorNodeVersion = process.version.split('.')[0];
+	var babelConfig = JSON.stringify(this.babelConfig);
+	var packageSalt = babelConfig + majorNodeVersion;
 
-CachingPrecompiler.prototype._createTransform = function () {
-	var salt = packageHash.sync([
-		require.resolve('../package.json'),
-		require.resolve('babel-core/package.json'),
-		require.resolve('babel-plugin-espower/package.json')
-	], JSON.stringify(this.babelConfig));
+	var salt = packageHash.sync(packages, packageSalt);
 
 	return cachingTransform({
-		factory: this._factory,
+		factory: this._init,
 		cacheDir: this.cacheDirPath,
 		hash: this._generateHash,
 		salt: salt,

package/lib/cli.js

@@ -0,0 +1,172 @@
+'use strict';
+var path = require('path');
+var updateNotifier = require('update-notifier');
+var figures = require('figures');
+var arrify = require('arrify');
+var meow = require('meow');
+var Promise = require('bluebird');
+var pkgConf = require('pkg-conf');
+var isCi = require('is-ci');
+var hasFlag = require('has-flag');
+var Api = require('../api');
+var colors = require('./colors');
+var verboseReporter = require('./reporters/verbose');
+var miniReporter = require('./reporters/mini');
+var tapReporter = require('./reporters/tap');
+var Logger = require('./logger');
+var Watcher = require('./watcher');
+var babelConfig = require('./babel-config');
+
+// Bluebird specific
+Promise.longStackTraces();
+
+exports.run = function () {
+	var conf = pkgConf.sync('ava');
+
+	var filepath = pkgConf.filepath(conf);
+	var pkgDir = filepath === null ? process.cwd() : path.dirname(filepath);
+
+	var 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',
+		'  --match, -m        Only run tests with matching title (Can be repeated)',
+		'  --watch, -w        Re-run tests when tests and source files change',
+		'  --source, -S       Pattern to match source files so tests can be re-run (Can be repeated)',
+		'  --timeout, -T      Set global timeout',
+		'  --concurrency, -c  Maximum number of test files running at the same time (EXPERIMENTAL)',
+		'',
+		'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: [
+			'_',
+			'timeout',
+			'source',
+			'match',
+			'concurrency'
+		],
+		boolean: [
+			'fail-fast',
+			'verbose',
+			'serial',
+			'tap',
+			'watch'
+		],
+		default: conf,
+		alias: {
+			t: 'tap',
+			v: 'verbose',
+			s: 'serial',
+			m: 'match',
+			w: 'watch',
+			S: 'source',
+			T: 'timeout',
+			c: 'concurrency'
+		}
+	});
+
+	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('--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.');
+	}
+
+	var 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 ? pkgDir : process.cwd(),
+		pkgDir: pkgDir,
+		timeout: cli.flags.timeout,
+		concurrency: cli.flags.concurrency ? parseInt(cli.flags.concurrency, 10) : 0
+	});
+
+	var reporter;
+
+	if (cli.flags.tap && !cli.flags.watch) {
+		reporter = tapReporter();
+	} else if (cli.flags.verbose || isCi) {
+		reporter = verboseReporter();
+	} else {
+		reporter = miniReporter({watching: cli.flags.watch});
+	}
+
+	reporter.api = api;
+	var logger = new Logger(reporter);
+
+	logger.start();
+
+	api.on('test-run', function (runStatus) {
+		reporter.api = runStatus;
+		runStatus.on('test', logger.test);
+		runStatus.on('error', logger.unhandledError);
+
+		runStatus.on('stdout', logger.stdout);
+		runStatus.on('stderr', logger.stderr);
+	});
+
+	var files = cli.input.length ? cli.input : arrify(conf.files);
+
+	if (cli.flags.watch) {
+		try {
+			var watcher = new Watcher(logger, api, files, arrify(cli.flags.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(function (runStatus) {
+				logger.finish(runStatus);
+				logger.exit(runStatus.failCount > 0 || runStatus.rejectionCount > 0 || runStatus.exceptionCount > 0 ? 1 : 0);
+			})
+			.catch(function (err) {
+				// Don't swallow exceptions. Note that any expected error should already
+				// have been logged.
+				setImmediate(function () {
+					throw err;
+				});
+			});
+	}
+};

package/lib/colors.js

@@ -2,10 +2,12 @@
 var chalk = require('chalk');
 
 module.exports = {
+	title: chalk.white,
 	error: chalk.red,
 	skip: chalk.yellow,
 	todo: chalk.blue,
 	pass: chalk.green,
 	duration: chalk.gray.dim,
+	errorStack: chalk.gray,
 	stack: chalk.red
 };

package/lib/concurrent.js

@@ -1,6 +1,7 @@
 'use strict';
 var Promise = require('bluebird');
 var isPromise = require('is-promise');
+var autoBind = require('auto-bind');
 var AvaError = require('./ava-error');
 
 function noop() {}
@@ -22,9 +23,7 @@ function Concurrent(tests, bail) {
 	this.tests = tests;
 	this.bail = bail || false;
 
-	Object.keys(Concurrent.prototype).forEach(function (key) {
-		this[key] = this[key].bind(this);
-	}, this);
+	autoBind(this);
 }
 
 Concurrent.prototype.run = function () {

package/lib/enhance-assert.js

@@ -13,6 +13,7 @@ module.exports.PATTERNS = [
 	't.deepEqual(value, expected, [message])',
 	't.notDeepEqual(value, expected, [message])',
 	't.regex(contents, regex, [message])',
+	't.notRegex(contents, regex, [message])',
 	// deprecated apis
 	't.ok(value, [message])',
 	't.notOk(value, [message])',
@@ -30,6 +31,7 @@ module.exports.NON_ENHANCED_PATTERNS = [
 
 function enhanceAssert(opts) {
 	var empower = require('empower-core');
+
 	var enhanced = empower(
 		opts.assert,
 		{
@@ -46,14 +48,21 @@ function enhanceAssert(opts) {
 }
 
 function formatter() {
-	var powerAssertFormatter = require('power-assert-formatter');
-	var powerAssertRenderers = require('power-assert-renderers');
+	var createFormatter = require('power-assert-context-formatter');
+	var SuccinctRenderer = require('power-assert-renderer-succinct');
+	var AssertionRenderer = require('power-assert-renderer-assertion');
 
-	return powerAssertFormatter({
-		maxDepth: 3,
+	return createFormatter({
 		renderers: [
-			powerAssertRenderers.AssertionRenderer,
-			powerAssertRenderers.SuccinctRenderer
+			{
+				ctor: AssertionRenderer
+			},
+			{
+				ctor: SuccinctRenderer,
+				options: {
+					maxDepth: 3
+				}
+			}
 		]
 	});
 }