[INTERNAL][WIP] VersionInfo: with manifest infos

added logic to use info for embeds

Author: tobiasso85

lib/processors/versionInfoGenerator.js

@@ -43,6 +43,7 @@ const processManifest = async (manifestResource) => {
 	if (manifestEmbeds) {
 		result.embeds = manifestEmbeds;
 	}
+	result.id = manifestObject["sap.app"]["id"];
 	return result;
 };
 
@@ -52,6 +53,8 @@ const processManifest = async (manifestResource) => {
  * @public
  * @typedef {object} DependencyInfos
  * @property {object} libs The library object
+ * @property {string[]} embeds embedded components
+ * @property {string} id id
  *
  *
  * @example
@@ -76,50 +79,98 @@ const processManifest = async (manifestResource) => {
  * @property {module:@ui5/fs.Resource[]} manifestResources list of corresponding manifest resources
  */
 
+const getManifestPath = (filePath, subPath) => {
+	if (filePath.endsWith("manifest.json")) {
+		return filePath.substr(0, filePath.length - "manifest.json".length) + subPath + "/manifest.json";
+	}
+	return filePath;
+};
 
 /**
  *
  * @param {Map<string, DependencyInfos>} manifestHints
  */
 const resolveTransitiveDependencies = (manifestHints) => {
-	manifestHints.forEach((manifestHint, key) => {
-		const resolvedLibs = {};
-		Object.keys(manifestHint.libs).forEach((libName) => {
-			resolvedLibs[libName] = manifestHint.libs[libName];
-			const resolved = resolve(libName, manifestHints, resolvedLibs);
-			Object.keys(resolved).forEach((nestedKey) => {
-				manifestHint.libs[nestedKey] = resolved[nestedKey];
-			});
-		});
+	// top level libraries
+	//  // lib.a => lib.c, lib.b
+	// 	// lib.b => lib.d
+	// 	// lib.c => lib.e, lib.b (true)
+	// 	// lib.d => lib.e (true)
+	// 	// lib.e =>
+	// TODO optimize duplicate resolve (e.g. cache)
+
+	// lib.c => lib.e, lib.b (true), lib.d
+	// lib.a => lib.c, lib.b, lib.d, lib.e
+	// lib.b => lib.d, lib.e (true)
+	// lib.d => lib.e (true)
+	// lib.e =>
+	const keys = [...manifestHints.keys()];
+	keys.sort();
+	const resolvedCache = new Map();
+	keys.forEach((libName) => {
+		resolve(libName, manifestHints, resolvedCache);
 	});
 };
 
-const isLazy = (obj1, obj2) => {
-	return obj1.lazy && obj2.lazy;
+const clone = (obj) => {
+	return JSON.parse(JSON.stringify(obj));
 };
 
 /**
  *
- * @param {string} libName
  * @param {Map<string, DependencyInfos>} manifestHints
- * @param {object} resolvedLibs
+ * @param {string} libName
+ * @param {object} newObject
  */
-const resolve = (libName, manifestHints, resolvedLibs) => {
-	const manifestHint = manifestHints.get(libName);
-	Object.keys(manifestHint.libs).forEach((childLibName) => {
-		if (resolvedLibs[childLibName] && !isLazy(manifestHint.libs[childLibName], resolvedLibs[childLibName])) {
-			resolvedLibs[childLibName] = {};
-		} else {
-			resolvedLibs[childLibName] = manifestHint.libs[childLibName];
-		}
+const setManifestHints = (manifestHints, libName, newObject) => {
+	const existingEntry = manifestHints.get(libName);
+	const newLibs = merge(existingEntry && existingEntry, newObject);
+	console.log(`  setting ${libName} ==> ${Object.keys(newLibs).join(", ")}`);
+	manifestHints.set(libName, newLibs);
+};
 
-		const nested = resolve(childLibName, manifestHints, resolvedLibs);
-		Object.keys(nested).forEach((nestedKey) => {
-			resolvedLibs[nestedKey] = resolvedLibs[nestedKey] || {};
+const merge = (existingEntry, newObject) => {
+	const newLibs = clone(newObject);
+	if (existingEntry) {
+		Object.keys(existingEntry).forEach((libName) => {
+			if (!existingEntry[libName].lazy && newLibs[libName] && newLibs[libName].lazy) {
+				newLibs[libName] = {};
+			}
+			if (!newLibs[libName]) {
+				newLibs[libName] = existingEntry[libName];
+			}
 		});
-	});
+	}
+	return newLibs;
+};
 
-	return resolvedLibs;
+/**
+ *
+ * @param {string} libName
+ * @param {Map<string, DependencyInfos>} manifestHints
+ * @param {Map<string, DependencyInfos>} resolvedCache
+ * @returns {DependencyInfos} resolved dependencies
+ */
+const resolve = (libName, manifestHints, resolvedCache) => {
+	// lib.c get entries
+	// lib.c => lib.b (true)
+	// lib.b =>
+	if ( resolvedCache.has(libName)) {
+		return resolvedCache.get(libName);
+	}
+	const manifestHint = manifestHints.get(libName); // lib.c
+	console.log(`:processing: ${libName}`);
+	const keys = Object.keys(manifestHint); // [lib.b]
+	let resolved = {};
+	keys.forEach((childLibName) => {
+		const childResolved = resolve(childLibName, manifestHints, resolvedCache);
+		resolved = merge(resolved, childResolved);
+		console.log(`resolved ${childLibName} with ${Object.keys(resolved).join(", ")}`);
+	});
+	resolved = merge(resolved, manifestHint);
+	setManifestHints(manifestHints, libName, resolved);
+	resolvedCache.set(libName, resolved);
+	return resolved;
 };
 
 
@@ -155,7 +206,7 @@ module.exports = async function({options}) {
 	const buildTimestamp = getTimestamp();
 	// TODO filter manifest.json if sap/embeds (we expect it contains the correct information)
 
-	const components = [];
+	const components = {};
 	/**
 	 * @example
 	 * "sap.ui.integration": {
@@ -168,27 +219,52 @@ module.exports = async function({options}) {
 	 * @type {Map<string, DependencyInfos>}
 	 */
 	const dependencyInfoMap = new Map();
+	const embeddedInfoMap = new Map();
 
 	// gather all manifestHints
 	const librariesPromises = options.libraryInfos.map((libraryInfo) => {
+		// TODO use proper async await!
 		return processManifest(libraryInfo.mainManifest).then((manifestHint) => {
-			dependencyInfoMap.set(libraryInfo.name, manifestHint);
+			dependencyInfoMap.set(libraryInfo.name, manifestHint.libs);
+			return manifestHint.embeds;
+		}).then((embeds) => {
+			// filter
+			embeds.forEach((embed) => {
+				embeddedInfoMap.set(embed, {
+					library: libraryInfo.name
+				});
+			});
+			const embeddedPaths = embeds.map((embed) => {
+				return getManifestPath(libraryInfo.mainManifest.getPath(), embed);
+			});
+			const relevantManifests = libraryInfo.manifestResources.filter((manifestResource) => {
+				return embeddedPaths.includes(manifestResource.getPath());
+			});
+
+			// get all embeds manifests
+			return Promise.all(relevantManifests.map((relevantManifest) => {
+				return processManifest(relevantManifest).then((result) => {
+					dependencyInfoMap.set(result.id, result.libs);
+				});
+			}));
 		});
 	});
 
+	// gather embeds' manifest and do the same
+
 	await Promise.all(librariesPromises);
 
 	console.log("before:");
 	dependencyInfoMap.forEach((manifestHint, key) => {
-		console.log(`${key} => ${out(manifestHint.libs).join(", ")}`);
+		console.log(`${key} => ${out(manifestHint).join(", ")}`);
 	});
 
 	// resolve nested dependencies (transitive)
 	resolveTransitiveDependencies(dependencyInfoMap);
 
 	console.log("\nafter:");
 	dependencyInfoMap.forEach((manifestHint, key) => {
-		console.log(`${key} => ${out(manifestHint.libs).join(", ")}`);
+		console.log(`${key} => ${out(manifestHint).join(", ")}`);
 	});
 
 
@@ -200,7 +276,8 @@ module.exports = async function({options}) {
 			scmRevision: ""// TODO: insert current library scm revision here
 		};
 
-		const libs = dependencyInfoMap.get(libraryInfo.name).libs;
+		const libs = dependencyInfoMap.get(libraryInfo.name);
+		// TODO: sort the libs
 		if (Object.keys(libs).length) {
 			result.manifestHints = {
 				dependencies: {
@@ -211,10 +288,29 @@ module.exports = async function({options}) {
 		return result;
 	});
 
+	// TODO sort!
+	embeddedInfoMap.forEach((embeddedInfo, libName) => {
+		components[libName] = {
+			library: embeddedInfo.library
+		};
+		const libs = dependencyInfoMap.get(libName);
+		if (libs && Object.keys(libs).length) {
+			components[libName].manifestHints = {
+				dependencies: {
+					libs: libs
+				}
+			};
+		}
+	});
+
+	// sort alphabetically
+	libraries.sort((a, b) => {
+		return a.name.localeCompare(b.name);
+	});
+
 
 	// TODO enrich components
 
-
 	const versionJson = {
 		name: options.rootProjectName,
 		version: options.rootProjectVersion, // TODO: insert current application version here