Add extension support to ProjectGraph

RandomByte · RandomByte · commit f653a799d000 · 2021-02-14T16:20:21.000+01:00
diff --git a/lib/graph/ProjectGraph.js b/lib/graph/ProjectGraph.js
@@ -10,18 +10,17 @@ class ProjectGraph {
 	 * @public
 	 * @param {object} parameters Parameters
 	 * @param {string} parameters.rootProjectName Root project name
-	 * @param {Array.<module:@ui5/project.specification.Extension>} parameters.extensions
-	 * 													Final list of extensions to be used in this project tree
 	 */
-	constructor({rootProjectName, extensions = []}) {
+	constructor({rootProjectName}) {
 		if (!rootProjectName) {
 			throw new Error(`Could not create ProjectGraph: Missing or empty parameter 'rootProjectName'`);
 		}
 		this._rootProjectName = rootProjectName;
-		this._extensions = Object.freeze(extensions);
 
 		this._projects = {}; // maps project name to instance
 		this._adjList = {}; // maps project name to edges/dependencies
+
+		this._extensions = {}; // maps extension name to instance
 	}
 
 	getRoot() {
@@ -32,14 +31,19 @@ class ProjectGraph {
 		return rootProject;
 	}
 
+	/**
+	 * @public
+	 * @param {module:@ui5/project.specification.Project} project Project which should be added to the graph
+	 * @param {boolean} [ignoreDuplicates=false] Whether an error should be thrown when a duplicate project is added
+	 */
 	addProject(project, ignoreDuplicates) {
 		const projectName = project.getName();
 		if (this._projects[projectName]) {
 			if (ignoreDuplicates) {
 				return;
 			}
 			throw new Error(
-				`Failed to add project ${projectName} to the graph: A project with that name has already been added`);
+				`Failed to add project ${projectName} to graph: A project with that name has already been added`);
 		}
 		if (!isNaN(projectName)) {
 			// Reject integer-like project names. They would take precedence when traversing object keys which
@@ -51,10 +55,46 @@ class ProjectGraph {
 		this._adjList[projectName] = {};
 	}
 
+	/**
+	 * @public
+	 * @param {string} projectName Name of the project to retrieve
+	 * @returns {module:@ui5/project.specification.project|undefined}
+	 *					project instance or undefined if the project is unknown to the graph
+	 */
 	getProject(projectName) {
 		return this._projects[projectName];
 	}
 
+	/**
+	 * @public
+	 * @param {module:@ui5/project.specification.Extension} extension Extension which should be available in the graph
+	 */
+	addExtension(extension) {
+		const extensionName = extension.getName();
+		if (this._extensions[extensionName]) {
+			throw new Error(
+				`Failed to add extension ${extensionName} to graph: ` +
+				`An extension with that name has already been added`);
+		}
+		if (!isNaN(extensionName)) {
+			// Reject integer-like extension names. They would take precedence when traversing object keys which
+			// might lead to unexpected behavior in the future. We don't really expect anyone to use such names anyways
+			throw new Error(
+				`Failed to add extension ${extensionName} to graph: Extension name must not be integer-like`);
+		}
+		this._extensions[extensionName] = extension;
+	}
+
+	/**
+	 * @public
+	 * @param {string} extensionName Name of the extension to retrieve
+	 * @returns {module:@ui5/project.specification.Extension|undefined}
+	 *					Extension instance or undefined if the extension is unknown to the graph
+	 */
+	getExtension(extensionName) {
+		return this._extensions[extensionName];
+	}
+
 	/**
 	 * Declare a dependency from one project in the graph to another
 	 *
diff --git a/lib/graph/projectGraphFromTree.js b/lib/graph/projectGraphFromTree.js
@@ -4,6 +4,26 @@ const ProjectGraph = require("./ProjectGraph");
 const ShimCollection = require("./ShimCollection");
 const log = require("@ui5/logger").getLogger("graph:projectGraphFromTree");
 
+
+function _handleExtensions(graph, shimCollection, extensions) {
+	extensions.forEach((extension) => {
+		const type = extension.getType();
+		switch (type) {
+		case "project-shim":
+			shimCollection.addShim(extension);
+			break;
+		case "task":
+		case "server-middleware":
+			graph.addExtension(extension);
+			break;
+		default:
+			throw new Error(
+				`Encountered unexpected extension of type ${type} ` +
+				`Supported types are 'project-shim', 'task' and 'middleware'`);
+		}
+	});
+}
+
 /**
  * Tree node
  *
@@ -22,15 +42,6 @@ const log = require("@ui5/logger").getLogger("graph:projectGraphFromTree");
  */
 module.exports = async function(tree) {
 	const shimCollection = new ShimCollection();
-
-	function addShimsToCollection(ext) {
-		ext.forEach((e) => {
-			if (e.getType() === "project-shim") {
-				shimCollection.addShim(e);
-			}
-		});
-	}
-
 	const moduleCollection = {};
 
 	const rootModule = new Module({
@@ -57,13 +68,18 @@ module.exports = async function(tree) {
 		qualifiedApplicationProject = rootProject;
 	}
 
-	addShimsToCollection(rootExtensions);
 
 	const projectGraph = new ProjectGraph({
 		rootProjectName: rootProjectName
 	});
 	projectGraph.addProject(rootProject);
 
+	function handleExtensions(extensions) {
+		return _handleExtensions(projectGraph, shimCollection, extensions);
+	}
+
+	handleExtensions(rootExtensions);
+
 	const queue = [];
 
 	if (tree.dependencies) {
@@ -142,10 +158,8 @@ module.exports = async function(tree) {
 				// Skip this node
 				continue;
 			}
-			if (extensions.length) {
-				addShimsToCollection(extensions);
-				extensions.push(extensions);
-			}
+
+			handleExtensions(extensions);
 
 			if (project) {
 				const projectName = project.getName();
diff --git a/test/lib/extensions.js b/test/lib/extensions.js
@@ -583,7 +583,6 @@ test("Project with unknown extension dependency inline configuration", (t) => {
 });
 
 test("Project with task extension dependency", (t) => {
-	// "project-type" extension handling not yet implemented => test currently checks for error
 	const tree = {
 		id: "application.a",
 		path: applicationAPath,
@@ -617,7 +616,6 @@ test("Project with task extension dependency", (t) => {
 });
 
 test("Project with task extension dependency - does not throw for invalid task path", async (t) => {
-	// "project-type" extension handling not yet implemented => test currently checks for error
 	const tree = {
 		id: "application.a",
 		path: applicationAPath,
@@ -648,7 +646,6 @@ test("Project with task extension dependency - does not throw for invalid task p
 
 
 test("Project with middleware extension dependency", (t) => {
-	// "project-type" extension handling not yet implemented => test currently checks for error
 	const tree = {
 		id: "application.a",
 		path: applicationAPath,
@@ -683,7 +680,6 @@ test("Project with middleware extension dependency", (t) => {
 });
 
 test("Project with middleware extension dependency - middleware is missing configuration", async (t) => {
-	// "project-type" extension handling not yet implemented => test currently checks for error
 	const tree = {
 		id: "application.a",
 		path: applicationAPath,
diff --git a/test/lib/graph/ProjectGraph.js b/test/lib/graph/ProjectGraph.js
@@ -4,12 +4,13 @@ const mock = require("mock-require");
 const logger = require("@ui5/logger");
 const Configuration = require("../../../lib/specifications/Configuration");
 const Project = require("../../../lib/specifications/Project");
-// const Extension = require("../../../lib/specifications/Extension");
+const Extension = require("../../../lib/specifications/Extension");
 
 function createProject(name) {
 	const basicConfiguration = new Configuration({
 		specVersion: "2.3",
 		kind: "project",
+		type: "application",
 		metadata: {name}
 	});
 
@@ -20,6 +21,21 @@ function createProject(name) {
 		configuration: basicConfiguration
 	});
 }
+function createExtension(name) {
+	const basicConfiguration = new Configuration({
+		specVersion: "2.3",
+		kind: "extension",
+		type: "task",
+		metadata: {name}
+	});
+
+	return new Extension({
+		id: "application.a.id",
+		version: "1.0.0",
+		modulePath: "some path",
+		configuration: basicConfiguration
+	});
+}
 
 function traverseBreadthFirst(...args) {
 	return _traverse(...args, true);
@@ -71,22 +87,15 @@ test("Instantiate a basic project graph", async (t) => {
 	const {ProjectGraph} = t.context;
 	t.notThrows(() => {
 		new ProjectGraph({
-			rootProjectName: "my root project",
-			extensions: [
-				"some extension"
-			]
+			rootProjectName: "my root project"
 		});
 	}, "Should not throw");
 });
 
 test("Instantiate a basic project with missing parameter rootProjectName", async (t) => {
 	const {ProjectGraph} = t.context;
 	const error = t.throws(() => {
-		new ProjectGraph({
-			extensions: [
-				"some extension"
-			]
-		});
+		new ProjectGraph({});
 	});
 	t.is(error.message, "Could not create ProjectGraph: Missing or empty parameter 'rootProjectName'",
 		"Should throw with expected error message");
@@ -141,7 +150,7 @@ test("addProject: Add duplicate", async (t) => {
 		graph.addProject(project2);
 	});
 	t.is(error.message,
-		"Failed to add project application.a to the graph: A project with that name has already been added",
+		"Failed to add project application.a to graph: A project with that name has already been added",
 		"Should throw with expected error message");
 
 	const res = graph.getProject("application.a");
@@ -189,6 +198,61 @@ test("getProject: Project is not in graph", async (t) => {
 	t.is(res, undefined, "Should return undefined");
 });
 
+test("add-/getExtension", async (t) => {
+	const {ProjectGraph} = t.context;
+	const graph = new ProjectGraph({
+		rootProjectName: "my root project"
+	});
+	const extension = createExtension("extension.a");
+	graph.addExtension(extension);
+	const res = graph.getExtension("extension.a");
+	t.is(res, extension, "Should return correct extension");
+});
+
+test("addExtension: Add duplicate", async (t) => {
+	const {ProjectGraph} = t.context;
+	const graph = new ProjectGraph({
+		rootProjectName: "my root project"
+	});
+	const extension1 = createExtension("extension.a");
+	graph.addExtension(extension1);
+
+	const extension2 = createExtension("extension.a");
+	const error = t.throws(() => {
+		graph.addExtension(extension2);
+	});
+	t.is(error.message,
+		"Failed to add extension extension.a to graph: An extension with that name has already been added",
+		"Should throw with expected error message");
+
+	const res = graph.getExtension("extension.a");
+	t.is(res, extension1, "Should return correct extension");
+});
+
+test("addExtension: Add extension with integer-like name", async (t) => {
+	const {ProjectGraph} = t.context;
+	const graph = new ProjectGraph({
+		rootProjectName: "my root project"
+	});
+	const extension = createExtension("1337");
+
+	const error = t.throws(() => {
+		graph.addExtension(extension);
+	});
+	t.is(error.message,
+		"Failed to add extension 1337 to graph: Extension name must not be integer-like",
+		"Should throw with expected error message");
+});
+
+test("getExtension: Project is not in graph", async (t) => {
+	const {ProjectGraph} = t.context;
+	const graph = new ProjectGraph({
+		rootProjectName: "my root project"
+	});
+	const res = graph.getExtension("extension.a");
+	t.is(res, undefined, "Should return undefined");
+});
+
 test("declareDependency / getDependencies", async (t) => {
 	const {ProjectGraph} = t.context;
 	const graph = new ProjectGraph({
diff --git a/test/lib/graph/projectGraphFromTree.js b/test/lib/graph/projectGraphFromTree.js
