[FEATURE] Builder: Add handling for custom task configurations

As per RFC0004: SAP/ui5-tooling#54

index.js

@@ -23,7 +23,8 @@ const ui5Builder = {
 		generateVersionInfo: require("./lib/tasks/generateVersionInfo"),
 		replaceCopyright: require("./lib/tasks/replaceCopyright"),
 		replaceVersion: require("./lib/tasks/replaceVersion"),
-		uglify: require("./lib/tasks/uglify")
+		uglify: require("./lib/tasks/uglify"),
+		taskRepository: require("./lib/tasks/taskRepository")
 	},
 	types: {
 		AbstractBuilder: require("./lib/types/AbstractBuilder"),

lib/builder/builder.js

@@ -1,23 +1,9 @@
 const log = require("@ui5/logger").getGroupLogger("builder:builder");
 const resourceFactory = require("@ui5/fs").resourceFactory;
 const typeRepository = require("../types/typeRepository");
+const taskRepository = require("../tasks/taskRepository");
 
-const definedTasks = {
-	replaceCopyright: require("../tasks/replaceCopyright"),
-	replaceVersion: require("../tasks/replaceVersion"),
-	createDebugFiles: require("../tasks/createDebugFiles"),
-	uglify: require("../tasks/uglify"),
-	buildThemes: require("../tasks/buildThemes"),
-	generateLibraryManifest: require("../tasks/generateLibraryManifest"),
-	generateVersionInfo: require("../tasks/generateVersionInfo"),
-	generateManifestBundle: require("../tasks/bundlers/generateManifestBundle"),
-	generateFlexChangesBundle: require("../tasks/bundlers/generateFlexChangesBundle"),
-	generateComponentPreload: require("../tasks/bundlers/generateComponentPreload"),
-	generateStandaloneAppBundle: require("../tasks/bundlers/generateStandaloneAppBundle"),
-	generateBundle: require("../tasks/bundlers/generateBundle"),
-	generateLibraryPreload: require("../tasks/bundlers/generateLibraryPreload")
-};
-
+const definedTasks = taskRepository.getAllTasks();
 
 // Set of tasks for development
 const devTasks = [

lib/tasks/taskRepository.js

@@ -0,0 +1,41 @@
+const tasks = {
+	replaceCopyright: require("./replaceCopyright"),
+	replaceVersion: require("./replaceVersion"),
+	createDebugFiles: require("./createDebugFiles"),
+	uglify: require("./uglify"),
+	buildThemes: require("./buildThemes"),
+	generateLibraryManifest: require("./generateLibraryManifest"),
+	generateVersionInfo: require("./generateVersionInfo"),
+	generateManifestBundle: require("./bundlers/generateManifestBundle"),
+	generateFlexChangesBundle: require("./bundlers/generateFlexChangesBundle"),
+	generateComponentPreload: require("./bundlers/generateComponentPreload"),
+	generateStandaloneAppBundle: require("./bundlers/generateStandaloneAppBundle"),
+	generateBundle: require("./bundlers/generateBundle"),
+	generateLibraryPreload: require("./bundlers/generateLibraryPreload")
+};
+
+function getTask(taskName) {
+	const task = tasks[taskName];
+
+	if (!task) {
+		throw new Error(`taskRepository: Unkown Task ${taskName}`);
+	}
+	return task;
+}
+
+function addTask(name, task) {
+	if (tasks[name]) {
+		throw new Error(`taskRepository: Task ${name} already registered`);
+	}
+	tasks[name] = task;
+}
+
+function getAllTasks() {
+	return tasks;
+}
+
+module.exports = {
+	getTask: getTask,
+	addTask: addTask,
+	getAllTasks: getAllTasks
+};

lib/types/AbstractBuilder.js

@@ -7,30 +7,140 @@ class AbstractBuilder {
 	/**
 	 * Constructor
 	 *
+	 * @param {object} resourceCollections Resource collections
+	 * @param {DuplexCollection} resourceCollections.workspace Workspace Resource
+	 * @param {ReaderCollection} resourceCollections.dependencies Workspace Resource
 	 * @param {object} project Project configuration
 	 * @param {GroupLogger} parentLogger Logger to use
 	 */
-	constructor({project, parentLogger}) {
-		this.tasks = {};
+	constructor({resourceCollections, project, parentLogger}) {
+		if (new.target === AbstractBuilder) {
+			throw new TypeError("Class 'AbstractBuilder' is abstract");
+		}
+
+		this.project = project;
+
 		this.log = parentLogger.createSubLogger(project.type + " " + project.metadata.name, 0.2);
 		this.taskLog = this.log.createTaskLogger("🔨");
-		this.availableTasks = [];
+
+		this.tasks = {};
+		this.taskExecutionOrder = [];
+		this.addStandardTasks({resourceCollections, project});
+		this.addCustomTasks({resourceCollections, project});
+	}
+
+	/**
+	 * Adds all standard tasks to execute
+	 *
+	 * @abstract
+	 * @protected
+ 	 * @param {object} resourceCollections Resource collections
+	 * @param {DuplexCollection} resourceCollections.workspace Workspace Resource
+	 * @param {ReaderCollection} resourceCollections.dependencies Workspace Resource
+	 * @param {object} project Project configuration
+	 */
+	addStandardTasks() {
+		throw new Error("Function 'addStandardTasks' is not implemented");
+	}
+
+	/**
+	 * Adds custom tasks to execute
+	 *
+	 * @private
+ 	 * @param {object} resourceCollections Resource collections
+	 * @param {DuplexCollection} resourceCollections.workspace Workspace Resource
+	 * @param {ReaderCollection} resourceCollections.dependencies Workspace Resource
+	 * @param {object} project Project configuration
+	 */
+	addCustomTasks({resourceCollections, project}) {
+		const projectCustomTasks = project.builder && project.builder.customTasks;
+		if (!projectCustomTasks || projectCustomTasks.length === 0) {
+			return; // No custom tasks defined
+		}
+		const taskRepository = require("../tasks/taskRepository");
+		for (let i = 0; i < projectCustomTasks.length; i++) {
+			const taskDef = projectCustomTasks[i];
+			if (!taskDef.name) {
+				throw new Error(`Missing name for custom task definition of project ${project.metadata.name} ` +
+					`at index ${i}`);
+			}
+			if (taskDef.beforeTask && taskDef.afterTask) {
+				throw new Error(`Custom task definition ${taskDef.name} of project ${project.metadata.name} ` +
+					`defines both "beforeTask" and "afterTask" parameters. Only one must be defined.`);
+			}
+			if (!taskDef.beforeTask && !taskDef.afterTask) {
+				throw new Error(`Custom task definition ${taskDef.name} of project ${project.metadata.name} ` +
+					`defines neither a "beforeTask" nor an "afterTask" parameter. One must be defined.`);
+			}
+
+			let newTaskName = taskDef.name;
+			if (this.tasks[newTaskName]) {
+				// Task is already known
+				// => add a suffix to allow for multiple configurations of the same task
+				let suffixCounter = 0;
+				while (this.tasks[newTaskName]) {
+					suffixCounter++; // Start at 1
+					newTaskName = `${newTaskName}--${suffixCounter}`;
+				}
+			}
+			// Create custom task if not already done (task might be referenced multiple times, first one wins)
+			const task = taskRepository.getTask(taskDef.name);
+			const execTask = function() {
+				/* Custom Task Interface
+					Parameters:
+						{Object} parameters Parameters
+						{DuplexCollection} parameters.workspace DuplexCollection to read and write files
+						{AbstractReader} parameters.dependencies Reader or Collection to read dependency files
+						{Object} parameters.options Options
+						{string} parameters.options.projectName Project name
+						{string} [parameters.options.configuration] Task configuration if given in ui5.yaml
+					Returns:
+						{Promise<undefined>} Promise resolving with undefined once data has been written
+				*/
+				return task({
+					workspace: resourceCollections.workspace,
+					dependencies: resourceCollections.dependencies,
+					options: {
+						projectName: project.metadata.name,
+						configuration: taskDef.configuration
+					}
+				});
+			};
+
+			this.tasks[newTaskName] = execTask;
+
+			const refTaskName = taskDef.beforeTask || taskDef.afterTask;
+			let refTaskIdx = this.taskExecutionOrder.indexOf(refTaskName);
+			if (refTaskIdx === -1) {
+				throw new Error(`Could not find task ${refTaskName}, referenced by custom task ${newTaskName}, ` +
+					`to be scheduled for project ${project.metadata.name}`);
+			}
+			if (taskDef.afterTask) {
+				// Insert after index of referenced task
+				refTaskIdx++;
+			}
+			this.taskExecutionOrder.splice(refTaskIdx, 0, newTaskName);
+		}
 	}
 
 	/**
 	 * Adds a executable task to the builder
 	 *
-	 * This does not ensure the correct build order. The order is maintained through the property
-	 * [availableTasks]{@link AbstractBuilder#availableTasks}
+	 * The order this function is being called defines the build order. FIFO.
 	 *
 	 * @param {string} taskName Name of the task which should be in the list availableTasks.
 	 * @param {function} taskFunction
 	 */
 	addTask(taskName, taskFunction) {
-		if (this.availableTasks.indexOf(taskName) === -1) {
-			throw new Error(`Task "${taskName}" does not exist.`);
+		if (this.tasks[taskName]) {
+			throw new Error(`Failed to add duplicative task ${taskName} for project ${this.project.metadata.name}`);
+		}
+		if (this.taskExecutionOrder.includes(taskName)) {
+			throw new Error(`Builder: Failed ot add task ${taskName} for project ${this.project.metadata.name}. ` +
+				`It has already been scheduled for execution.`);
 		}
 		this.tasks[taskName] = taskFunction;
+		this.taskExecutionOrder.push(taskName);
 	}
 
 	/**
@@ -40,21 +150,17 @@ class AbstractBuilder {
 	 * @returns {Promise} Returns promise chain with tasks
 	 */
 	build(tasksToRun) {
-		const allTasksCount = tasksToRun.filter((value) => this.availableTasks.includes(value)).length;
+		const allTasksCount = tasksToRun.filter((value) => this.tasks.hasOwnProperty(value)).length;
 		this.taskLog.addWork(allTasksCount);
 
 		let taskChain = Promise.resolve();
-		for (let i = 0; i < this.availableTasks.length; i++) {
-			const taskName = this.availableTasks[i];
-
-			if (!tasksToRun.includes(taskName)) {
-				continue;
-			}
-
-			const taskFunction = this.tasks[taskName];
+		for (const taskName in this.tasks) {
+			if (this.tasks.hasOwnProperty(taskName) && tasksToRun.includes(taskName)) {
+				const taskFunction = this.tasks[taskName];
 
-			if (typeof taskFunction === "function") {
-				taskChain = taskChain.then(this.wrapTask(taskName, taskFunction));
+				if (typeof taskFunction === "function") {
+					taskChain = taskChain.then(this.wrapTask(taskName, taskFunction));
+				}
 			}
 		}
 		return taskChain;

lib/types/application/ApplicationBuilder.js

@@ -15,23 +15,7 @@ const tasks = { // can't require index.js due to circular dependency
 };
 
 class ApplicationBuilder extends AbstractBuilder {
-	constructor({resourceCollections, project, parentLogger}) {
-		super({project, parentLogger});
-
-		// All available application tasks in execution order
-		this.availableTasks = [
-			"replaceCopyright",
-			"replaceVersion",
-			"generateFlexChangesBundle",
-			"generateManifestBundle",
-			"generateComponentPreload",
-			"generateStandaloneAppBundle",
-			"generateBundle",
-			"createDebugFiles",
-			"uglify",
-			"generateVersionInfo"
-		];
-
+	addStandardTasks({resourceCollections, project}) {
 		this.addTask("replaceCopyright", () => {
 			return tasks.replaceCopyright({
 				workspace: resourceCollections.workspace,

lib/types/library/LibraryBuilder.js

@@ -16,22 +16,7 @@ const tasks = { // can't require index.js due to circular dependency
 };
 
 class LibraryBuilder extends AbstractBuilder {
-	constructor({resourceCollections, project, parentLogger}) {
-		super({project, parentLogger});
-
-		// All available library tasks in execution order
-		this.availableTasks = [
-			"replaceCopyright",
-			"replaceVersion",
-			"generateComponentPreload",
-			"generateBundle",
-			"generateLibraryManifest",
-			"generateLibraryPreload",
-			"buildThemes",
-			"createDebugFiles",
-			"uglify"
-		];
-
+	addStandardTasks({resourceCollections, project, parentLogger}) {
 		this.addTask("replaceCopyright", () => {
 			const replaceCopyright = tasks.replaceCopyright;
 			return replaceCopyright({

lib/types/module/ModuleBuilder.js

@@ -2,11 +2,10 @@ const AbstractBuilder = require("../AbstractBuilder");
 
 class ModuleBuilder extends AbstractBuilder {
 	constructor({resourceCollections, project, parentLogger}) {
-		super({project, parentLogger});
-
-		// All available library tasks in execution order
-		this.availableTasks = [];
+		super({resourceCollections, project, parentLogger});
 	}
+
+	addStandardTasks() {/* nothing to do*/}
 }
 
 module.exports = ModuleBuilder;