Move Babel transforms to the main process.

.travis.yml

@@ -6,4 +6,4 @@ node_js:
 before_install:
   - 'npm i -g npm@latest'
 after_success:
-  - '[ -z "$COVERALLS_REPO_TOKEN" ] && tap --coverage-report=text-lcov | ./node_modules/.bin/coveralls'
+  - 'cat ./coverage/lcov.info | ./node_modules/.bin/coveralls'

api.js

@@ -9,8 +9,10 @@ var figures = require('figures');
 var globby = require('globby');
 var chalk = require('chalk');
 var resolveCwd = require('resolve-cwd');
+var objectAssign = require('object-assign');
 var fork = require('./lib/fork');
 var formatter = require('./lib/enhance-assert').formatter();
+var CachingPrecompiler = require('./lib/caching-precompiler');
 
 function Api(files, options) {
 	if (!(this instanceof Api)) {
@@ -42,7 +44,10 @@ util.inherits(Api, EventEmitter);
 module.exports = Api;
 
 Api.prototype._runFile = function (file) {
-	return fork(file, this.options)
+	var options = objectAssign({}, this.options, {
+		precompiled: this.precompiler.generateHashForFile(file)
+	});
+	return fork(file, options)
 		.on('stats', this._handleStats)
 		.on('test', this._handleTest)
 		.on('unhandledRejections', this._handleRejections)
@@ -135,6 +140,10 @@ Api.prototype.run = function () {
 			if (files.length === 0) {
 				return Promise.reject(new Error('Couldn\'t find any files to test'));
 			}
+			var cache = self.options.cache !== false;
+			var cacheDir = (cache && CachingPrecompiler.findCacheDir(files)) || CachingPrecompiler.findUniqueTempDir();
+			self.options.cacheDir = cacheDir;
+			self.precompiler = new CachingPrecompiler(cacheDir);
 
 			self.fileCount = files.length;
 

cli.js

@@ -37,6 +37,7 @@ var cli = meow([
 	'  --init       Add AVA to your project',
 	'  --fail-fast  Stop after first test failure',
 	'  --serial     Run tests serially',
+	'  --no-cache   Disable the transpiler cache',
 	'  --require    Module to preload (Can be repeated)',
 	'  --tap        Generate TAP output',
 	'',
@@ -77,7 +78,8 @@ if (cli.flags.tap) {
 var api = new Api(cli.input, {
 	failFast: cli.flags.failFast,
 	serial: cli.flags.serial,
-	require: arrify(cli.flags.require)
+	require: arrify(cli.flags.require),
+	cache: cli.flags.cache !== false
 });
 
 api.on('test', function (test) {

lib/babel.js

@@ -20,59 +20,52 @@ var globals = require('./globals');
 
 var sourceMapCache = Object.create(null);
 
+var fs = require('fs');
 var sourceMapSupport = require('source-map-support');
 sourceMapSupport.install({
 	handleUncaughtExceptions: false,
 	retrieveSourceMap: function (source) {
 		if (sourceMapCache[source]) {
 			return {
 				url: source,
-				map: sourceMapCache[source]
+				map: fs.readFileSync(sourceMapCache[source], 'utf8')
 			};
 		}
 	}
 });
 
-var createEspowerPlugin = require('babel-plugin-espower/create');
-var requireFromString = require('require-from-string');
 var loudRejection = require('loud-rejection/api')(process);
 var serializeError = require('serialize-error');
-var babel = require('babel-core');
 var send = require('./send');
+var installPrecompiler = require('require-precompiled');
+var path = require('path');
+var cacheDir = opts.cacheDir;
 
 var testPath = opts.file;
 
-// initialize power-assert
-var powerAssert = createEspowerPlugin(babel, {
-	patterns: require('./enhance-assert').PATTERNS
-});
-
-// if generators are not supported, use regenerator
-var options = {
-	presets: [require('babel-preset-stage-2'), require('babel-preset-es2015')],
-	plugins: [powerAssert, require('babel-plugin-transform-runtime')],
-	sourceMaps: true
-};
-
 // check if test files required ava and show error, when they didn't
 exports.avaRequired = false;
 
-// try to load an input source map for the test file, in case the file was
-// already compiled once by the user
-var inputSourceMap = sourceMapSupport.retrieveSourceMap(testPath);
-if (inputSourceMap) {
-	// source-map-support returns the source map as a json-encoded string, but
-	// babel requires an actual object
-	options.inputSourceMap = JSON.parse(inputSourceMap.map);
-}
-
-// include test file
-var transpiled = babel.transformFileSync(testPath, options);
-sourceMapCache[testPath] = transpiled.map;
-requireFromString(transpiled.code, testPath, {
-	appendPaths: module.paths
+installPrecompiler(function (filename) {
+	var precompiled = opts.precompiled[filename];
+	if (precompiled) {
+		sourceMapCache[filename] = path.join(cacheDir, precompiled + '.map');
+		return fs.readFileSync(path.join(cacheDir, precompiled + '.js'), 'utf8');
+	}
+	return null;
 });
 
+// Modules need to be able to find `babel-runtime`, which is nested in our node_modules w/ npm@2
+var nodeModulesDir = path.join(__dirname, '../node_modules');
+var oldNodeModulesPaths = module.constructor._nodeModulePaths;
+module.constructor._nodeModulePaths = function () {
+	var ret = oldNodeModulesPaths.apply(this, arguments);
+	ret.push(nodeModulesDir);
+	return ret;
+};
+
+require(testPath);
+
 process.on('uncaughtException', function (exception) {
 	send('uncaughtException', {exception: serializeError(exception)});
 });

lib/caching-precompiler.js

@@ -0,0 +1,112 @@
+var cachingTransform = require('caching-transform');
+var fs = require('fs');
+var path = require('path');
+var md5Hex = require('md5-hex');
+var commonDir = require('commondir');
+var pkgDir = require('pkg-dir');
+var osTmpdir = require('os-tmpdir');
+var stripBom = require('strip-bom');
+
+module.exports = CachingPrecompiler;
+module.exports.findCacheDir = findCacheDir;
+module.exports.findUniqueTempDir = findUniqueTempDir;
+
+function findCacheDir(files) {
+	var projectBaseDirectory = pkgDir.sync(commonDir(files));
+	return path.join(projectBaseDirectory, 'node_modules', '.cache', 'ava');
+}
+
+function findUniqueTempDir() {
+	return path.join(
+		osTmpdir(),
+		Math.random().toString(35).substr(2, 30)
+	);
+}
+
+function CachingPrecompiler(cacheDir) {
+	if (!(this instanceof CachingPrecompiler)) {
+		throw new Error('CachingPrecompiler must be called with new');
+	}
+	this.cacheDir = cacheDir;
+	this.filenameToHash = {};
+	this.transform = this._createTransform();
+}
+
+CachingPrecompiler.prototype._factory = function (cacheDir) {
+	// This factory method is only called once per process, and only as needed, to defer loading expensive dependencies.
+	var babel = require('babel-core');
+	var convertSourceMap = require('convert-source-map');
+	var presetStage2 = require('babel-preset-stage-2');
+	var presetES2015 = require('babel-preset-es2015');
+	var transformRuntime = require('babel-plugin-transform-runtime');
+
+	var powerAssert = this._createEspowerPlugin(babel);
+
+	function buildOptions(filename, code) {
+		// Extract existing source maps from the code.
+		var sourceMap = convertSourceMap.fromSource(code) || convertSourceMap.fromMapFileSource(code, path.dirname(filename));
+
+		return {
+			presets: [presetStage2, presetES2015],
+			plugins: [powerAssert, transformRuntime],
+			filename: filename,
+			sourceMaps: true,
+			ast: false,
+			inputSourceMap: sourceMap && sourceMap.toObject()
+		};
+	}
+
+	return function (code, filename, hash) {
+		code = code.toString('utf8');
+		var options = buildOptions(filename, code);
+		var result = babel.transform(code, options);
+		var mapFile = path.join(cacheDir, hash + '.map');
+		fs.writeFileSync(mapFile, JSON.stringify(result.map));
+		return result.code;
+	};
+};
+
+CachingPrecompiler.prototype._createEspowerPlugin = function (babel) {
+	var createEspowerPlugin = require('babel-plugin-espower/create');
+	var enhanceAssert = require('./enhance-assert');
+
+	// initialize power-assert
+	return createEspowerPlugin(babel, {
+		patterns: enhanceAssert.PATTERNS
+	});
+};
+
+CachingPrecompiler.prototype._createTransform = function () {
+	var self = this;
+
+	return cachingTransform({
+		factory: this._factory.bind(this),
+		cacheDir: self.cacheDir,
+		salt: new Buffer(JSON.stringify({
+			'babel-plugin-espower': require('babel-plugin-espower/package.json').version,
+			'ava': require('../package.json').version,
+			'babel-core': require('babel-core/package.json').version
+		})),
+		ext: '.js',
+		hash: this._hash.bind(this)
+	});
+};
+
+CachingPrecompiler.prototype._hash = function (code, filename, salt) {
+	var hash = md5Hex([code, filename, salt]);
+	this.filenameToHash[filename] = hash;
+	return hash;
+};
+
+CachingPrecompiler.prototype.precompileFile = function (filename) {
+	if (!this.filenameToHash[filename]) {
+		this.transform(stripBom(fs.readFileSync(filename)), filename);
+	}
+	return this.filenameToHash[filename];
+};
+
+CachingPrecompiler.prototype.generateHashForFile = function (filename) {
+	var hash = {};
+	hash[filename] = this.precompileFile(filename);
+	return hash;
+};

package.json

@@ -37,9 +37,9 @@
     "node": ">=0.10.0"
   },
   "scripts": {
-    "test": "xo && tap --coverage --reporter=spec --timeout=150 test/*.js",
-    "test-win": "tap --reporter=spec --timeout=150 test/*.js",
-    "coverage": "tap --coverage-report=lcov"
+    "pretest": "de ./node_modules/.cache",
+    "test": "xo && nyc --reporter=lcov ./node_modules/.bin/tap --no-cov --timeout=150 test/*.js",
+    "test-win": "npm run pretest && tap -b --no-cov --timeout=150 --reporter=classic test/*.js"
   },
   "files": [
     "index.js",
@@ -88,8 +88,11 @@
     "babel-preset-stage-2": "^6.3.13",
     "babel-runtime": "^6.3.19",
     "bluebird": "^3.0.0",
+    "caching-transform": "^1.0.0",
     "chalk": "^1.0.0",
     "co-with-promise": "^4.6.0",
+    "commondir": "^1.0.1",
+    "convert-source-map": "^1.1.2",
     "core-assert": "^0.1.0",
     "debug": "^2.2.0",
     "deeper": "^2.1.0",
@@ -102,40 +105,38 @@
     "is-promise": "^2.1.0",
     "loud-rejection": "^1.2.0",
     "max-timeout": "^1.0.0",
+    "md5-hex": "^1.2.0",
     "meow": "^3.6.0",
     "object-assign": "^4.0.1",
     "observable-to-promise": "^0.1.0",
+    "os-tmpdir": "^1.0.1",
+    "pkg-dir": "^1.0.0",
     "plur": "^2.0.0",
     "power-assert-formatter": "^1.3.0",
     "power-assert-renderers": "^0.1.0",
     "pretty-ms": "^2.0.0",
-    "require-from-string": "^1.1.0",
+    "require-precompiled": "^0.1.0",
     "resolve-cwd": "^1.0.0",
     "serialize-error": "^1.1.0",
     "set-immediate-shim": "^1.0.1",
     "source-map-support": "^0.4.0",
     "squeak": "^1.2.0",
+    "strip-bom": "^2.0.0",
     "time-require": "^0.1.2",
     "update-notifier": "^0.5.0"
   },
   "devDependencies": {
     "coveralls": "^2.11.4",
+    "del-cli": "^0.1.2",
     "hook-std": "^0.1.0",
+    "nyc": "^5.0.1",
     "signal-exit": "^2.1.2",
     "sinon": "^1.17.2",
     "source-map-fixtures": "^0.3.0",
     "tap": "^2.2.1",
     "xo": "*",
     "zen-observable": "^0.1.6"
   },
-  "config": {
-    "nyc": {
-      "exclude": [
-        "node_modules[/\\\\]",
-        "test[/\\\\]"
-      ]
-    }
-  },
   "xo": {
     "ignore": [
       "cli.js"

test/fork.js

@@ -1,12 +1,22 @@
 'use strict';
 var path = require('path');
 var test = require('tap').test;
-var fork = require('../lib/fork.js');
+var _fork = require('../lib/fork.js');
+var CachingPrecompiler = require('../lib/caching-precompiler');
+var cacheDir = path.join(__dirname, '../node_modules/.cache/ava');
+var precompiler = new CachingPrecompiler(cacheDir);
 
 function fixture(name) {
 	return path.join(__dirname, 'fixture', name);
 }
 
+function fork(testPath) {
+	return _fork(testPath, {
+		cacheDir: cacheDir,
+		precompiled: precompiler.generateHashForFile(testPath)
+	});
+}
+
 test('emits test event', function (t) {
 	t.plan(1);
 
@@ -33,18 +43,6 @@ test('resolves promise with tests info', function (t) {
 		});
 });
 
-test('rejects on error and streams output', function (t) {
-	t.plan(2);
-
-	fork(fixture('broken.js'))
-		.run()
-		.catch(function (err) {
-			t.ok(err);
-			t.match(err.message, /exited with a non-zero exit code: \d/);
-			t.end();
-		});
-});
-
 test('exit after tests are finished', function (t) {
 	t.plan(2);
 

test/hooks.js

@@ -2,7 +2,17 @@
 var path = require('path');
 var test = require('tap').test;
 var Runner = require('../lib/runner');
-var fork = require('../lib/fork');
+var _fork = require('../lib/fork');
+var CachingPrecompiler = require('../lib/caching-precompiler');
+var cacheDir = path.join(__dirname, '../node_modules/.cache/ava');
+var precompiler = new CachingPrecompiler(cacheDir);
+
+function fork(testPath) {
+	return _fork(testPath, {
+		cacheDir: cacheDir,
+		precompiled: precompiler.generateHashForFile(testPath)
+	});
+}
 
 test('before', function (t) {
 	t.plan(1);