ava 0.16.0 → 0.18.2

package/lib/watcher.js

@@ -1,357 +1,318 @@
 'use strict';
-var nodePath = require('path');
-var debug = require('debug')('ava:watcher');
-var diff = require('lodash.difference');
-var chokidar = require('chokidar');
-var flatten = require('arr-flatten');
-var union = require('array-union');
-var uniq = require('array-uniq');
-var AvaFiles = require('ava-files');
+const nodePath = require('path');
+const debug = require('debug')('ava:watcher');
+const diff = require('lodash.difference');
+const chokidar = require('chokidar');
+const flatten = require('arr-flatten');
+const union = require('array-union');
+const uniq = require('array-uniq');
+const AvaFiles = require('./ava-files');
 
 function rethrowAsync(err) {
-	// Don't swallow exceptions. Note that any expected error should already have
-	// been logged.
-	setImmediate(function () {
+	// Don't swallow exceptions. Note that any
+	// expected error should already have been logged
+	setImmediate(() => {
 		throw err;
 	});
 }
 
-function Watcher(logger, api, files, sources) {
-	this.debouncer = new Debouncer(this);
-	this.avaFiles = new AvaFiles({
-		files: files,
-		sources: sources
-	});
-
-	this.isTest = this.avaFiles.makeTestMatcher();
-
-	this.clearLogOnNextRun = true;
-	this.runVector = 0;
-	this.run = function (specificFiles) {
-		if (this.runVector > 0) {
-			var cleared = this.clearLogOnNextRun && logger.clear();
-			if (!cleared) {
-				logger.reset();
-				logger.section();
-			}
-			this.clearLogOnNextRun = true;
-
-			logger.reset();
-			logger.start();
+class Debouncer {
+	constructor(watcher) {
+		this.watcher = watcher;
+		this.timer = null;
+		this.repeat = false;
+	}
+	debounce() {
+		if (this.timer) {
+			this.again = true;
+			return;
 		}
 
-		var currentVector = this.runVector += 1;
+		const timer = this.timer = setTimeout(() => {
+			this.watcher.busy.then(() => {
+				// Do nothing if debouncing was canceled while waiting for the busy
+				// promise to fulfil
+				if (this.timer !== timer) {
+					return;
+				}
+
+				if (this.again) {
+					this.timer = null;
+					this.again = false;
+					this.debounce();
+				} else {
+					this.watcher.runAfterChanges();
+					this.timer = null;
+					this.again = false;
+				}
+			});
+		}, 10);
+	}
+	cancel() {
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = null;
+			this.again = false;
+		}
+	}
+}
 
-		var runOnlyExclusive = false;
+class TestDependency {
+	constructor(file, sources) {
+		this.file = file;
+		this.sources = sources;
+	}
+	contains(source) {
+		return this.sources.indexOf(source) !== -1;
+	}
+}
 
-		if (specificFiles) {
-			var exclusiveFiles = specificFiles.filter(function (file) {
-				return this.filesWithExclusiveTests.indexOf(file) !== -1;
-			}, this);
+class Watcher {
+	constructor(logger, api, files, sources) {
+		this.debouncer = new Debouncer(this);
+		this.avaFiles = new AvaFiles({
+			files,
+			sources
+		});
 
-			runOnlyExclusive = exclusiveFiles.length !== this.filesWithExclusiveTests.length;
+		this.clearLogOnNextRun = true;
+		this.runVector = 0;
+		this.run = specificFiles => {
+			if (this.runVector > 0) {
+				const cleared = this.clearLogOnNextRun && logger.clear();
+				if (!cleared) {
+					logger.reset();
+					logger.section();
+				}
+				this.clearLogOnNextRun = true;
 
-			if (runOnlyExclusive) {
-				// The test files that previously contained exclusive tests are always
-				// run, together with the remaining specific files.
-				var remainingFiles = diff(specificFiles, exclusiveFiles);
-				specificFiles = this.filesWithExclusiveTests.concat(remainingFiles);
+				logger.reset();
+				logger.start();
 			}
-		}
 
-		var self = this;
-		this.busy = api.run(specificFiles || files, {
-			runOnlyExclusive: runOnlyExclusive
-		}).then(function (runStatus) {
-			runStatus.previousFailCount = self.sumPreviousFailures(currentVector);
-			logger.finish(runStatus);
+			const currentVector = this.runVector += 1;
 
-			var badCounts = runStatus.failCount + runStatus.rejectionCount + runStatus.exceptionCount;
-			self.clearLogOnNextRun = self.clearLogOnNextRun && badCounts === 0;
-		}, rethrowAsync);
-	};
+			let runOnlyExclusive = false;
 
-	this.testDependencies = [];
-	this.trackTestDependencies(api, sources);
+			if (specificFiles) {
+				const exclusiveFiles = specificFiles.filter(file => this.filesWithExclusiveTests.indexOf(file) !== -1);
 
-	this.filesWithExclusiveTests = [];
-	this.trackExclusivity(api);
+				runOnlyExclusive = exclusiveFiles.length !== this.filesWithExclusiveTests.length;
 
-	this.filesWithFailures = [];
-	this.trackFailures(api);
+				if (runOnlyExclusive) {
+					// The test files that previously contained exclusive tests are always
+					// run, together with the remaining specific files.
+					const remainingFiles = diff(specificFiles, exclusiveFiles);
+					specificFiles = this.filesWithExclusiveTests.concat(remainingFiles);
+				}
+			}
 
-	this.dirtyStates = {};
-	this.watchFiles();
-	this.rerunAll();
-}
+			this.busy = api.run(specificFiles || files, {runOnlyExclusive})
+				.then(runStatus => {
+					runStatus.previousFailCount = this.sumPreviousFailures(currentVector);
+					logger.finish(runStatus);
 
-module.exports = Watcher;
+					const badCounts = runStatus.failCount + runStatus.rejectionCount + runStatus.exceptionCount;
+					this.clearLogOnNextRun = this.clearLogOnNextRun && badCounts === 0;
+				})
+				.catch(rethrowAsync);
+		};
 
-Watcher.prototype.watchFiles = function () {
-	var self = this;
-	var patterns = this.avaFiles.getChokidarPatterns();
-
-	chokidar.watch(patterns.paths, {
-		ignored: patterns.ignored,
-		ignoreInitial: true
-	}).on('all', function (event, path) {
-		if (event === 'add' || event === 'change' || event === 'unlink') {
-			debug('Detected %s of %s', event, path);
-			self.dirtyStates[path] = event;
-			self.debouncer.debounce();
-		}
-	});
-};
+		this.testDependencies = [];
+		this.trackTestDependencies(api, sources);
 
-Watcher.prototype.trackTestDependencies = function (api) {
-	var self = this;
-	var isSource = this.avaFiles.makeSourceMatcher();
+		this.filesWithExclusiveTests = [];
+		this.trackExclusivity(api);
 
-	var relative = function (absPath) {
-		return nodePath.relative('.', absPath);
-	};
+		this.filesWithFailures = [];
+		this.trackFailures(api);
 
-	api.on('test-run', function (runStatus) {
-		runStatus.on('dependencies', function (file, dependencies) {
-			var sourceDeps = dependencies.map(relative).filter(isSource);
-			self.updateTestDependencies(file, sourceDeps);
+		this.dirtyStates = {};
+		this.watchFiles();
+		this.rerunAll();
+	}
+	watchFiles() {
+		const patterns = this.avaFiles.getChokidarPatterns();
+
+		chokidar.watch(patterns.paths, {
+			ignored: patterns.ignored,
+			ignoreInitial: true
+		}).on('all', (event, path) => {
+			if (event === 'add' || event === 'change' || event === 'unlink') {
+				debug('Detected %s of %s', event, path);
+				this.dirtyStates[path] = event;
+				this.debouncer.debounce();
+			}
 		});
-	});
-};
-
-Watcher.prototype.updateTestDependencies = function (file, sources) {
-	if (sources.length === 0) {
-		this.testDependencies = this.testDependencies.filter(function (dep) {
-			return dep.file !== file;
+	}
+	trackTestDependencies(api) {
+		const relative = absPath => nodePath.relative(process.cwd(), absPath);
+
+		api.on('test-run', runStatus => {
+			runStatus.on('dependencies', (file, dependencies) => {
+				const sourceDeps = dependencies.map(relative).filter(this.avaFiles.isSource);
+				this.updateTestDependencies(file, sourceDeps);
+			});
 		});
-
-		return;
 	}
-
-	var isUpdate = this.testDependencies.some(function (dep) {
-		if (dep.file !== file) {
-			return false;
+	updateTestDependencies(file, sources) {
+		if (sources.length === 0) {
+			this.testDependencies = this.testDependencies.filter(dep => dep.file !== file);
+			return;
 		}
 
-		dep.sources = sources;
-
-		return true;
-	});
-
-	if (!isUpdate) {
-		this.testDependencies.push(new TestDependency(file, sources));
-	}
-};
-
-Watcher.prototype.trackExclusivity = function (api) {
-	var self = this;
-
-	api.on('stats', function (stats) {
-		self.updateExclusivity(stats.file, stats.hasExclusive);
-	});
-};
-
-Watcher.prototype.updateExclusivity = function (file, hasExclusiveTests) {
-	var index = this.filesWithExclusiveTests.indexOf(file);
-
-	if (hasExclusiveTests && index === -1) {
-		this.filesWithExclusiveTests.push(file);
-	} else if (!hasExclusiveTests && index !== -1) {
-		this.filesWithExclusiveTests.splice(index, 1);
-	}
-};
-
-Watcher.prototype.trackFailures = function (api) {
-	var self = this;
+		const isUpdate = this.testDependencies.some(dep => {
+			if (dep.file !== file) {
+				return false;
+			}
 
-	api.on('test-run', function (runStatus, files) {
-		files.forEach(function (file) {
-			self.pruneFailures(nodePath.relative('.', file));
-		});
+			dep.sources = sources;
 
-		var currentVector = self.runVector;
-		runStatus.on('error', function (err) {
-			self.countFailure(err.file, currentVector);
-		});
-		runStatus.on('test', function (result) {
-			if (result.error) {
-				self.countFailure(result.file, currentVector);
-			}
+			return true;
 		});
-	});
-};
-
-Watcher.prototype.pruneFailures = function (file) {
-	this.filesWithFailures = this.filesWithFailures.filter(function (state) {
-		return state.file !== file;
-	});
-};
 
-Watcher.prototype.countFailure = function (file, vector) {
-	var isUpdate = this.filesWithFailures.some(function (state) {
-		if (state.file !== file) {
-			return false;
+		if (!isUpdate) {
+			this.testDependencies.push(new TestDependency(file, sources));
 		}
-
-		state.count++;
-		return true;
-	});
-
-	if (!isUpdate) {
-		this.filesWithFailures.push({
-			file: file,
-			vector: vector,
-			count: 1
+	}
+	trackExclusivity(api) {
+		api.on('stats', stats => {
+			this.updateExclusivity(stats.file, stats.hasExclusive);
 		});
 	}
-};
-
-Watcher.prototype.sumPreviousFailures = function (beforeVector) {
-	var total = 0;
+	updateExclusivity(file, hasExclusiveTests) {
+		const index = this.filesWithExclusiveTests.indexOf(file);
 
-	this.filesWithFailures.forEach(function (state) {
-		if (state.vector < beforeVector) {
-			total += state.count;
+		if (hasExclusiveTests && index === -1) {
+			this.filesWithExclusiveTests.push(file);
+		} else if (!hasExclusiveTests && index !== -1) {
+			this.filesWithExclusiveTests.splice(index, 1);
 		}
-	});
-
-	return total;
-};
-
-Watcher.prototype.cleanUnlinkedTests = function (unlinkedTests) {
-	unlinkedTests.forEach(function (testFile) {
-		this.updateTestDependencies(testFile, []);
-		this.updateExclusivity(testFile, false);
-		this.pruneFailures(testFile);
-	}, this);
-};
-
-Watcher.prototype.observeStdin = function (stdin) {
-	var self = this;
+	}
+	trackFailures(api) {
+		api.on('test-run', (runStatus, files) => {
+			files.forEach(file => {
+				this.pruneFailures(nodePath.relative(process.cwd(), file));
+			});
+
+			const currentVector = this.runVector;
+			runStatus.on('error', err => {
+				this.countFailure(err.file, currentVector);
+			});
+			runStatus.on('test', result => {
+				if (result.error) {
+					this.countFailure(result.file, currentVector);
+				}
+			});
+		});
+	}
+	pruneFailures(file) {
+		this.filesWithFailures = this.filesWithFailures.filter(state => state.file !== file);
+	}
+	countFailure(file, vector) {
+		const isUpdate = this.filesWithFailures.some(state => {
+			if (state.file !== file) {
+				return false;
+			}
 
-	stdin.resume();
-	stdin.setEncoding('utf8');
+			state.count++;
+			return true;
+		});
 
-	stdin.on('data', function (data) {
-		data = data.trim().toLowerCase();
-		if (data !== 'r' && data !== 'rs') {
-			return;
+		if (!isUpdate) {
+			this.filesWithFailures.push({
+				file,
+				vector,
+				count: 1
+			});
 		}
+	}
+	sumPreviousFailures(beforeVector) {
+		let total = 0;
 
-		// Cancel the debouncer, it might rerun specific tests whereas *all* tests
-		// need to be rerun.
-		self.debouncer.cancel();
-		self.busy.then(function () {
-			// Cancel the debouncer again, it might have restarted while waiting for
-			// the busy promise to fulfil.
-			self.debouncer.cancel();
-			self.clearLogOnNextRun = false;
-			self.rerunAll();
+		this.filesWithFailures.forEach(state => {
+			if (state.vector < beforeVector) {
+				total += state.count;
+			}
 		});
-	});
-};
-
-Watcher.prototype.rerunAll = function () {
-	this.dirtyStates = {};
-	this.run();
-};
-
-Watcher.prototype.runAfterChanges = function () {
-	var dirtyStates = this.dirtyStates;
-	this.dirtyStates = {};
-
-	var dirtyPaths = Object.keys(dirtyStates);
-	var dirtyTests = dirtyPaths.filter(this.isTest);
-	var dirtySources = diff(dirtyPaths, dirtyTests);
-	var addedOrChangedTests = dirtyTests.filter(function (path) {
-		return dirtyStates[path] !== 'unlink';
-	});
-	var unlinkedTests = diff(dirtyTests, addedOrChangedTests);
 
-	this.cleanUnlinkedTests(unlinkedTests);
-	// No need to rerun tests if the only change is that tests were deleted.
-	if (unlinkedTests.length === dirtyPaths.length) {
-		return;
+		return total;
 	}
-
-	if (dirtySources.length === 0) {
-		// Run any new or changed tests.
-		this.run(addedOrChangedTests);
-		return;
+	cleanUnlinkedTests(unlinkedTests) {
+		unlinkedTests.forEach(testFile => {
+			this.updateTestDependencies(testFile, []);
+			this.updateExclusivity(testFile, false);
+			this.pruneFailures(testFile);
+		});
 	}
+	observeStdin(stdin) {
+		stdin.resume();
+		stdin.setEncoding('utf8');
 
-	// Try to find tests that depend on the changed source files.
-	var testsBySource = dirtySources.map(function (path) {
-		return this.testDependencies.filter(function (dep) {
-			return dep.contains(path);
-		}).map(function (dep) {
-			debug('%s is a dependency of %s', path, dep.file);
-			return dep.file;
-		});
-	}, this).filter(function (tests) {
-		return tests.length > 0;
-	});
+		stdin.on('data', data => {
+			data = data.trim().toLowerCase();
+			if (data !== 'r' && data !== 'rs') {
+				return;
+			}
 
-	// Rerun all tests if source files were changed that could not be traced to
-	// specific tests.
-	if (testsBySource.length !== dirtySources.length) {
-		debug('Sources remain that cannot be traced to specific tests. Rerunning all tests');
+			// Cancel the debouncer, it might rerun specific tests whereas *all* tests
+			// need to be rerun
+			this.debouncer.cancel();
+			this.busy.then(() => {
+				// Cancel the debouncer again, it might have restarted while waiting for
+				// the busy promise to fulfil
+				this.debouncer.cancel();
+				this.clearLogOnNextRun = false;
+				this.rerunAll();
+			});
+		});
+	}
+	rerunAll() {
+		this.dirtyStates = {};
 		this.run();
-		return;
 	}
+	runAfterChanges() {
+		const dirtyStates = this.dirtyStates;
+		this.dirtyStates = {};
 
-	// Run all affected tests.
-	this.run(union(addedOrChangedTests, uniq(flatten(testsBySource))));
-};
-
-function Debouncer(watcher) {
-	this.watcher = watcher;
-	this.timer = null;
-	this.repeat = false;
-}
+		const dirtyPaths = Object.keys(dirtyStates);
+		const dirtyTests = dirtyPaths.filter(this.avaFiles.isTest);
+		const dirtySources = diff(dirtyPaths, dirtyTests);
+		const addedOrChangedTests = dirtyTests.filter(path => dirtyStates[path] !== 'unlink');
+		const unlinkedTests = diff(dirtyTests, addedOrChangedTests);
 
-Debouncer.prototype.debounce = function () {
-	if (this.timer) {
-		this.again = true;
-		return;
-	}
+		this.cleanUnlinkedTests(unlinkedTests);
 
-	var self = this;
+		// No need to rerun tests if the only change is that tests were deleted
+		if (unlinkedTests.length === dirtyPaths.length) {
+			return;
+		}
 
-	var timer = this.timer = setTimeout(function () {
-		self.watcher.busy.then(function () {
-			// Do nothing if debouncing was canceled while waiting for the busy
-			// promise to fulfil.
-			if (self.timer !== timer) {
-				return;
-			}
+		if (dirtySources.length === 0) {
+			// Run any new or changed tests
+			this.run(addedOrChangedTests);
+			return;
+		}
 
-			if (self.again) {
-				self.timer = null;
-				self.again = false;
-				self.debounce();
-			} else {
-				self.watcher.runAfterChanges();
-				self.timer = null;
-				self.again = false;
-			}
-		});
-	}, 10);
-};
+		// Try to find tests that depend on the changed source files
+		const testsBySource = dirtySources.map(path => {
+			return this.testDependencies.filter(dep => dep.contains(path)).map(dep => {
+				debug('%s is a dependency of %s', path, dep.file);
+				return dep.file;
+			});
+		}, this).filter(tests => tests.length > 0);
+
+		// Rerun all tests if source files were changed that could not be traced to
+		// specific tests
+		if (testsBySource.length !== dirtySources.length) {
+			debug('Sources remain that cannot be traced to specific tests. Rerunning all tests');
+			this.run();
+			return;
+		}
 
-Debouncer.prototype.cancel = function () {
-	if (this.timer) {
-		clearTimeout(this.timer);
-		this.timer = null;
-		this.again = false;
+		// Run all affected tests
+		this.run(union(addedOrChangedTests, uniq(flatten(testsBySource))));
 	}
-};
-
-function TestDependency(file, sources) {
-	this.file = file;
-	this.sources = sources;
 }
 
-TestDependency.prototype.contains = function (source) {
-	return this.sources.indexOf(source) !== -1;
-};
+module.exports = Watcher;