webpack/lib/ContextModuleFactory.js

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/
"use strict";

const asyncLib = require("async");
const path = require("path");

const Tapable = require("tapable");
const ContextModule = require("./ContextModule");
const ContextElementDependency = require("./dependencies/ContextElementDependency");

module.exports = class ContextModuleFactory extends Tapable {
	constructor(resolvers) {
		super();
		this.resolvers = resolvers;
	}

	create(data, callback) {
		const context = data.context;
		const dependencies = data.dependencies;
		const dependency = dependencies[0];
		this.applyPluginsAsyncWaterfall("before-resolve", Object.assign({
			context: context,
			dependencies: dependencies
		}, dependency.options), (err, beforeResolveResult) => {
			if(err) return callback(err);

			// Ignored
			if(!beforeResolveResult) return callback();

			const context = beforeResolveResult.context;
			const request = beforeResolveResult.request;

			let loaders, resource, loadersPrefix = "";
			const idx = request.lastIndexOf("!");
			if(idx >= 0) {
				loaders = request.substr(0, idx + 1);
				let i;
				for(i = 0; i < loaders.length && loaders[i] === "!"; i++) {
					loadersPrefix += "!";
				}
				loaders = loaders.substr(i).replace(/!+$/, "").replace(/!!+/g, "!");
				if(loaders === "") loaders = [];
				else loaders = loaders.split("!");
				resource = request.substr(idx + 1);
			} else {
				loaders = [];
				resource = request;
			}

			const resolvers = this.resolvers;

			asyncLib.parallel([
				function(callback) {
					resolvers.context.resolve({}, context, resource, function(err, result) {
						if(err) return callback(err);
						callback(null, result);
					});
				},
				function(callback) {
					asyncLib.map(loaders, function(loader, callback) {
						resolvers.loader.resolve({}, context, loader, function(err, result) {
							if(err) return callback(err);
							callback(null, result);
						});
					}, callback);
				}
			], (err, result) => {
				if(err) return callback(err);

				this.applyPluginsAsyncWaterfall("after-resolve", Object.assign({
					addon: loadersPrefix + result[1].join("!") + (result[1].length > 0 ? "!" : ""),
					resource: result[0],
					resolveDependencies: this.resolveDependencies.bind(this),
				}, beforeResolveResult), function(err, result) {
					if(err) return callback(err);

					// Ignored
					if(!result) return callback();

					return callback(null, new ContextModule(result.resolveDependencies, result));
				});
			});
		});
	}

	resolveDependencies(fs, options, callback) {
		const cmf = this;
		let resource = options.resource;
		let recursive = options.recursive;
		let regExp = options.regExp;
		let include = options.include;
		let exclude = options.exclude;
		if(!regExp || !resource)
			return callback(null, []);
		(function addDirectory(directory, callback) {
			fs.readdir(directory, (err, files) => {
				if(err) return callback(err);
				files = cmf.applyPluginsWaterfall("context-module-files", files);
				if(!files || files.length === 0) return callback(null, []);
				asyncLib.map(files.filter(function(p) {
					return p.indexOf(".") !== 0;
				}), (seqment, callback) => {

					const subResource = path.join(directory, seqment);

					if(!exclude || !subResource.match(exclude)) {
						fs.stat(subResource, (err, stat) => {
							if(err) {
								if(err.code === "ENOENT") {
									// ENOENT is ok here because the file may have been deleted between
									// the readdir and stat calls.
									return callback();
								} else {
									return callback(err);
								}
							}

							if(stat.isDirectory()) {

								if(!recursive) return callback();
								addDirectory.call(this, subResource, callback);

							} else if(stat.isFile() && (!include || subResource.match(include))) {

								const obj = {
									context: resource,
									request: "." + subResource.substr(resource.length).replace(/\\/g, "/")
								};

								this.applyPluginsAsyncWaterfall("alternatives", [obj], (err, alternatives) => {
									if(err) return callback(err);
									alternatives = alternatives.filter(function(obj) {
										return regExp.test(obj.request);
									}).map(function(obj) {
										const dep = new ContextElementDependency(obj.request);
										dep.optional = true;
										return dep;
									});
									callback(null, alternatives);
								});

							} else callback();

						});
					} else callback();
				}, (err, result) => {
					if(err) return callback(err);

					if(!result) return callback(null, []);

					callback(null, result.filter(function(i) {
						return !!i;
					}).reduce(function(a, i) {
						return a.concat(i);
					}, []));
				});
			});
		}.call(this, resource, callback));
	}
};