Skip to content

Commit

Permalink
Merge pull request #5049 from KTruong888/ES6_refactoring_multicompiler
Browse files Browse the repository at this point in the history 
4099_ES6 refactor lib/MultiCompiler.js
  • Loading branch information
@sokra
sokra committed Jun 14, 2017
2 parents 7eb7529 + 18cdba8 commit 3ae782d
Showing 1 changed file with 136 additions and 148 deletions.
284 changes: 136 additions & 148 deletions lib/MultiCompiler.js
View file
Expand Up @@ -2,175 +2,163 @@
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
var Tapable = require("tapable");
var asyncLib = require("async");
var MultiWatching = require("./MultiWatching");
var MultiStats = require("./MultiStats");
"use strict";

function MultiCompiler(compilers) {
Tapable.call(this);
if(!Array.isArray(compilers)) {
compilers = Object.keys(compilers).map(function(name) {
compilers[name].name = name;
return compilers[name];
});
}
this.compilers = compilers;
const Tapable = require("tapable");
const asyncLib = require("async");
const MultiWatching = require("./MultiWatching");
const MultiStats = require("./MultiStats");

function delegateProperty(name) {
Object.defineProperty(this, name, {
configurable: false,
get: function() {
throw new Error("Cannot read " + name + " of a MultiCompiler");
},
set: function(value) {
this.compilers.forEach(function(compiler) {
compiler[name] = value;
});
}.bind(this)
});
module.exports = class MultiCompiler extends Tapable {
constructor(compilers) {
super();
if(!Array.isArray(compilers)) {
compilers = Object.keys(compilers).map((name) => {
compilers[name].name = name;
return compilers[name];
});
}
this.compilers = compilers;
let doneCompilers = 0;
let compilerStats = [];
this.compilers.forEach((compiler, idx) => {
let compilerDone = false;
compiler.plugin("done", stats => {
if(!compilerDone) {
compilerDone = true;
doneCompilers++;
}
compilerStats[idx] = stats;
if(doneCompilers === this.compilers.length) {
this.applyPlugins("done", new MultiStats(compilerStats));
}
});
compiler.plugin("invalid", () => {
if(compilerDone) {
compilerDone = false;
doneCompilers--;
}
this.applyPlugins("invalid");
});
}, this);
}
delegateProperty.call(this, "outputFileSystem");
delegateProperty.call(this, "inputFileSystem");

Object.defineProperty(this, "outputPath", {
configurable: false,
get: function() {
var commonPath = compilers[0].outputPath;
for(var i = 1; i < compilers.length; i++) {
while(compilers[i].outputPath.indexOf(commonPath) !== 0 && /[\/\\]/.test(commonPath)) {
commonPath = commonPath.replace(/[\/\\][^\/\\]*$/, "");
}
get outputPath() {
let commonPath = this.compilers[0].outputPath;
for(const compiler of this.compilers) {
while(compiler.outputPath.indexOf(commonPath) !== 0 && /[\/\\]/.test(commonPath)) {
commonPath = commonPath.replace(/[\/\\][^\/\\]*$/, "");
}
if(!commonPath && compilers[0].outputPath[0] === "/") return "/";
return commonPath;
}
});

var doneCompilers = 0;
var compilerStats = [];
this.compilers.forEach(function(compiler, idx) {
var compilerDone = false;
compiler.plugin("done", function(stats) {
if(!compilerDone) {
compilerDone = true;
doneCompilers++;
}
compilerStats[idx] = stats;
if(doneCompilers === this.compilers.length) {
this.applyPlugins("done", new MultiStats(compilerStats));
}
}.bind(this));
compiler.plugin("invalid", function() {
if(compilerDone) {
compilerDone = false;
doneCompilers--;
}
this.applyPlugins("invalid");
}.bind(this));
}, this);
}
module.exports = MultiCompiler;
if(!commonPath && this.compilers[0].outputPath[0] === "/") return "/";
return commonPath;
}

MultiCompiler.prototype = Object.create(Tapable.prototype);
MultiCompiler.prototype.constructor = MultiCompiler;
get inputFileSystem() {
throw new Error("Cannot read inputFileSystem of a MultiCompiler");
}

function runWithDependencies(compilers, fn, callback) {
var fulfilledNames = {};
var remainingCompilers = compilers;
get outputFileSystem() {
throw new Error("Cannot read outputFileSystem of a MultiCompiler");
}

function isDependencyFulfilled(d) {
return fulfilledNames[d];
set inputFileSystem(value) {
this.compilers.forEach(compiler => {
compiler.inputFileSystem = value;
});
}

function getReadyCompilers() {
var readyCompilers = [];
var list = remainingCompilers;
remainingCompilers = [];
for(var i = 0; i < list.length; i++) {
var c = list[i];
var ready = !c.dependencies || c.dependencies.every(isDependencyFulfilled);
if(ready)
readyCompilers.push(c);
else
remainingCompilers.push(c);
}
return readyCompilers;
set outputFileSystem(value) {
this.compilers.forEach(compiler => {
compiler.outputFileSystem = value;
});
}

function runCompilers(callback) {
if(remainingCompilers.length === 0) return callback();
asyncLib.map(getReadyCompilers(), function(compiler, callback) {
fn(compiler, function(err) {
if(err) return callback(err);
fulfilledNames[compiler.name] = true;
runCompilers(callback);
});
}, callback);
runWithDependencies(compilers, fn, callback) {
let fulfilledNames = {};
let remainingCompilers = compilers;
const isDependencyFulfilled = (d) => fulfilledNames[d];
const getReadyCompilers = () => {
let readyCompilers = [];
let list = remainingCompilers;
remainingCompilers = [];
for(const c of list) {
const ready = !c.dependencies || c.dependencies.every(isDependencyFulfilled);
if(ready)
readyCompilers.push(c);
else
remainingCompilers.push(c);
}
return readyCompilers;
};
const runCompilers = (callback) => {
if(remainingCompilers.length === 0) return callback();
asyncLib.map(getReadyCompilers(), (compiler, callback) => {
fn(compiler, (err) => {
if(err) return callback(err);
fulfilledNames[compiler.name] = true;
runCompilers(callback);
});
}, callback);
};
runCompilers(callback);
}
runCompilers(callback);
}

MultiCompiler.prototype.watch = function(watchOptions, handler) {
var watchings = [];
var allStats = this.compilers.map(function() {
return null;
});
var compilerStatus = this.compilers.map(function() {
return false;
});
runWithDependencies(this.compilers, function(compiler, callback) {
var compilerIdx = this.compilers.indexOf(compiler);
var firstRun = true;
var watching = compiler.watch(Array.isArray(watchOptions) ? watchOptions[compilerIdx] : watchOptions, function(err, stats) {
if(err)
handler(err);
if(stats) {
allStats[compilerIdx] = stats;
compilerStatus[compilerIdx] = "new";
if(compilerStatus.every(Boolean)) {
var freshStats = allStats.filter(function(s, idx) {
return compilerStatus[idx] === "new";
});
compilerStatus.fill(true);
var multiStats = new MultiStats(freshStats);
handler(null, multiStats);
watch(watchOptions, handler) {
let watchings = [];
let allStats = this.compilers.map(() => null);
let compilerStatus = this.compilers.map(() => false);
this.runWithDependencies(this.compilers, (compiler, callback) => {
const compilerIdx = this.compilers.indexOf(compiler);
let firstRun = true;
let watching = compiler.watch(Array.isArray(watchOptions) ? watchOptions[compilerIdx] : watchOptions, (err, stats) => {
if(err)
handler(err);
if(stats) {
allStats[compilerIdx] = stats;
compilerStatus[compilerIdx] = "new";
if(compilerStatus.every(Boolean)) {
const freshStats = allStats.filter((s, idx) => {
return compilerStatus[idx] === "new";
});
compilerStatus.fill(true);
const multiStats = new MultiStats(freshStats);
handler(null, multiStats);
}
}
}
if(firstRun && !err) {
firstRun = false;
callback();
}
if(firstRun && !err) {
firstRun = false;
callback();
}
});
watchings.push(watching);
}, () => {
// ignore
});
watchings.push(watching);
}.bind(this), function() {
// ignore
});

return new MultiWatching(watchings, this);
};

MultiCompiler.prototype.run = function(callback) {
var allStats = this.compilers.map(function() {
return null;
});
return new MultiWatching(watchings, this);
}

runWithDependencies(this.compilers, function(compiler, callback) {
var compilerIdx = this.compilers.indexOf(compiler);
compiler.run(function(err, stats) {
run(callback) {
const allStats = this.compilers.map(() => null);
this.runWithDependencies(this.compilers, ((compiler, callback) => {
const compilerIdx = this.compilers.indexOf(compiler);
compiler.run((err, stats) => {
if(err) return callback(err);
allStats[compilerIdx] = stats;
callback();
});
}), (err) => {
if(err) return callback(err);
allStats[compilerIdx] = stats;
callback();
callback(null, new MultiStats(allStats));
});
}.bind(this), function(err) {
if(err) return callback(err);
callback(null, new MultiStats(allStats));
});
};
}

MultiCompiler.prototype.purgeInputFileSystem = function() {
this.compilers.forEach(function(compiler) {
if(compiler.inputFileSystem && compiler.inputFileSystem.purge)
compiler.inputFileSystem.purge();
});
purgeInputFileSystem() {
this.compilers.forEach((compiler) => {
if(compiler.inputFileSystem && compiler.inputFileSystem.purge)
compiler.inputFileSystem.purge();
});
}
};

0 comments on commit 3ae782d

Please sign in to comment.