emit watch-close event when watcher closes

James Newell · James Newell · commit 2dfdbad047e7 · 2017-03-06T14:32:34.000+11:00
diff --git a/lib/Compiler.js b/lib/Compiler.js
@@ -131,10 +131,12 @@ Watching.prototype.close = function(callback) {
 	}
 	if(this.running) {
 		this.invalid = true;
-		this._done = function() {
+		this._done = () => {
+			this.compiler.applyPlugins("watch-close");
 			callback();
 		};
 	} else {
+		this.compiler.applyPlugins("watch-close");
 		callback();
 	}
 };
diff --git a/lib/MultiCompiler.js b/lib/MultiCompiler.js
@@ -148,7 +148,7 @@ MultiCompiler.prototype.watch = function(watchOptions, handler) {
 		// ignore
 	});
 
-	return new MultiWatching(watchings);
+	return new MultiWatching(watchings, this);
 };
 
 MultiCompiler.prototype.run = function(callback) {
diff --git a/lib/MultiWatching.js b/lib/MultiWatching.js
@@ -7,18 +7,25 @@
 const async = require("async");
 
 class MultiWatching {
-	constructor(watchings) {
+	constructor(watchings, compiler) {
 		this.watchings = watchings;
+		this.compiler = compiler;
 	}
 
 	invalidate() {
 		this.watchings.forEach((watching) => watching.invalidate());
 	}
 
 	close(callback) {
+		if(callback === undefined) callback = () => { /*do nothing*/ };
+
 		async.forEach(this.watchings, (watching, finishedCallback) => {
 			watching.close(finishedCallback);
-		}, callback);
+		}, err => {
+			this.compiler.applyPlugins("watch-close");
+			callback(err);
+		});
+
 	}
 }
 
diff --git a/test/MultiCompiler.test.js b/test/MultiCompiler.test.js
@@ -278,7 +278,7 @@ describe("MultiCompiler", () => {
 
 			it("returns a multi-watching object", () => {
 				const result = JSON.stringify(env.result);
-				result.should.be.exactly('{"watchings":["compiler1","compiler2"]}');
+				result.should.be.exactly('{"watchings":["compiler1","compiler2"],"compiler":{"_plugins":{},"compilers":[{"name":"compiler1"},{"name":"compiler2"}]}}');
 			});
 
 			it("calls watch on each compiler with original options", () => {
diff --git a/test/MultiWatching.test.js b/test/MultiWatching.test.js
@@ -1,5 +1,6 @@
 "use strict";
 
+const Tapable = require("tapable");
 const should = require("should");
 const sinon = require("sinon");
 const MultiWatching = require("../lib/MultiWatching");
@@ -11,12 +12,21 @@ const createWatching = function() {
 	};
 };
 
+const createCompiler = () => {
+	const compiler = {
+		_plugins: {}
+	};
+	Tapable.mixin(compiler);
+	return compiler;
+};
+
 describe("MultiWatching", () => {
-	let watchings, myMultiWatching;
+	let watchings, compiler, myMultiWatching;
 
 	beforeEach(() => {
 		watchings = [createWatching(), createWatching()];
-		myMultiWatching = new MultiWatching(watchings);
+		compiler = createCompiler();
+		myMultiWatching = new MultiWatching(watchings, compiler);
 	});
 
 	describe("invalidate", () => {
diff --git a/test/WatcherEvents.test.js b/test/WatcherEvents.test.js
@@ -0,0 +1,69 @@
+"use strict";
+
+/*globals describe it before after  */
+const path = require("path");
+const should = require("should");
+const MemoryFs = require("memory-fs");
+const webpack = require("../");
+
+const createCompiler = config => {
+	const compiler = webpack(config);
+	compiler.outputFileSystem = new MemoryFs();
+	return compiler;
+};
+
+const createSingleCompiler = () => {
+	return createCompiler({
+		context: path.join(__dirname, "fixtures"),
+		entry: "./a.js"
+	});
+};
+
+const createMultiCompiler = () => {
+	return createCompiler([{
+		context: path.join(__dirname, "fixtures"),
+		entry: "./a.js"
+	}]);
+};
+
+describe("WatchEvents", () => {
+
+	it("should emit 'watch-close' when using single-compiler mode and the compiler is not running", function(done) {
+		let called = false;
+
+		const compiler = createSingleCompiler();
+		const watcher = compiler.watch({}, (err, stats) => {
+			called.should.be.exactly(true);
+			done(err);
+		});
+
+		compiler.plugin('watch-close', () => {
+			called = true
+		});
+
+		compiler.plugin('done', () => {
+			watcher.close();
+		});
+
+	});
+
+	it("should emit 'watch-close' when using multi-compiler mode and the compiler is not running", function(done) {
+		let called = false;
+
+		const compiler = createMultiCompiler();
+		const watcher = compiler.watch({}, (err, stats) => {
+			called.should.be.exactly(true);
+			done(err);
+		});
+
+		compiler.plugin('watch-close', () => {
+			called = true
+		});
+
+		compiler.plugin('done', () => {
+			watcher.close();
+		});
+
+	});
+
+});

Original file line number	Diff line number	Diff line change
`@@ -131,10 +131,12 @@ Watching.prototype.close = function(callback) {`
`131`	`131`	`}`
`132`	`132`	`if(this.running) {`
`133`	`133`	`this.invalid = true;`
`134`		`- this._done = function() {`
	`134`	`+ this._done = () => {`
	`135`	`+ this.compiler.applyPlugins("watch-close");`
`135`	`136`	`callback();`
`136`	`137`	`};`
`137`	`138`	`} else {`
	`139`	`+ this.compiler.applyPlugins("watch-close");`
`138`	`140`	`callback();`
`139`	`141`	`}`
`140`	`142`	`};`
Original file line number	Diff line number	Diff line change
`@@ -7,18 +7,25 @@`
`7`	`7`	`const async = require("async");`
`8`	`8`
`9`	`9`	`class MultiWatching {`
`10`		`- constructor(watchings) {`
	`10`	`+ constructor(watchings, compiler) {`
`11`	`11`	`this.watchings = watchings;`
	`12`	`+ this.compiler = compiler;`
`12`	`13`	`}`
`13`	`14`
`14`	`15`	`invalidate() {`
`15`	`16`	`this.watchings.forEach((watching) => watching.invalidate());`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`close(callback) {`
	`20`	`+ if(callback === undefined) callback = () => { /do nothing/ };`
	`21`	`+`
`19`	`22`	`async.forEach(this.watchings, (watching, finishedCallback) => {`
`20`	`23`	`watching.close(finishedCallback);`
`21`		`- }, callback);`
	`24`	`+ }, err => {`
	`25`	`+ this.compiler.applyPlugins("watch-close");`
	`26`	`+ callback(err);`
	`27`	`+ });`
	`28`	`+`
`22`	`29`	`}`
`23`	`30`	`}`
`24`	`31`