[FEATURE] manifestCreator: i18n section v22

refactoring of dependency resolution logic

Author: tobiasso85

lib/processors/versionInfoGenerator.js

@@ -118,92 +118,107 @@ const getManifestPath = (filePath, subPath) => {
 const resolveTransitiveDependencies = (libraryInfosMap) => {
 	const keys = [...libraryInfosMap.keys()];
 	keys.sort();
-	const resolvedCache = new Map();
 	keys.forEach((libName) => { // e.g. sap.ui.documentation
-		resolve(libName, libraryInfosMap, resolvedCache);
+		const libraryInfo = libraryInfosMap.get(libName);
+		libraryInfo.resolve(libraryInfosMap);
 	});
 };
 
-const clone = (obj) => {
-	return JSON.parse(JSON.stringify(obj));
-};
+class DependencyInfoObject {
+	/**
+	 *
+	 * @param {string} name
+	 * @param {boolean} lazy
+	 */
+	constructor(name, lazy) {
+		this.name = name;
+		this.lazy = lazy;
+	}
+}
 
-const merge = (existingEntry, newLibs) => {
-	if (existingEntry) {
-		Object.keys(existingEntry).forEach((libName) => {
-			if (!existingEntry[libName].lazy && newLibs[libName] && newLibs[libName].lazy) {
-				delete newLibs[libName].lazy;
-			}
-			if (!newLibs[libName]) {
-				newLibs[libName] = existingEntry[libName];
-			}
-		});
+class DependencyInfo {
+	/**
+	 *
+	 * @param {DependencyInfoObject[]} libs
+	 */
+	constructor(libs) {
+		this.libs = libs;
+
+		/**
+		 *
+		 * @type {string[]}
+		 */
+		this.resolved = [];
+		/**
+		 *
+		 * @type {DependencyInfoObject[]}
+		 */
+		this.libsResolved = [];
+		this.wasResolved = false;
 	}
-	return newLibs;
-};
 
-/**
- *
- * @param {string} libName
- * @param {Map<string, DependencyInfos>} libraryInfosMap
- * @param {Map<string, DependencyInfos>} alreadyProcessed
- * @returns {DependencyInfos} resolved dependencies
- */
-const resolve = (libName, libraryInfosMap, alreadyProcessed, isLazy) => {
-	// check already processed first
-	if ( alreadyProcessed.has(libName)) {
-		return alreadyProcessed.get(libName);
+	isResolved(libName) {
+		return this.libsResolved.some((libResolved) => {
+			return libResolved.name === libName;
+		});
 	}
-	const manifestHint = libraryInfosMap.get(libName);
-	let mergedDependencies = manifestHint;
-	// cache
-	alreadyProcessed.set(libName, mergedDependencies);
-	if (!manifestHint) {
-		log.error(`no manifest information in dependencies for ${libName}`); // TODO check
-		alreadyProcessed.set(libName, {});
-		return {};
+
+	addResolvedLibDependency(libName, lazy) {
+		if (!this.isResolved(libName) || !lazy) {
+			this.libsResolved.push(new DependencyInfoObject(libName, lazy));
+		}
 	}
-	const keys = Object.keys(manifestHint);
-	keys.forEach((childLibName) => {
-		const childResolved = resolve(childLibName, libraryInfosMap, alreadyProcessed, isLazy);
-		// set a copy of the resolved libraries to avoid modifying it while iterating (recursively)
-		mergedDependencies = merge(mergedDependencies, clone(childResolved), isLazy);
-		// TODO add childResolved to resolved
-		// TODO check cacles
 
+	/**
+	 *
+	 * @param {Map<string,DependencyInfo>} dependencyInfoMap
+	 */
+	resolve(dependencyInfoMap) {
+		if (!this.wasResolved) {
+			this.libs.forEach((depInfoObject) => {
+				this.addResolvedLibDependency(depInfoObject.name, depInfoObject.lazy);
+				const dependencyInfo = dependencyInfoMap.get(depInfoObject.name);
+				dependencyInfo.resolve(dependencyInfoMap);
+
+				dependencyInfo.libsResolved.forEach((resolvedLib) => {
+					this.addResolvedLibDependency(resolvedLib.name, resolvedLib.lazy);
+				});
+			});
+			this.wasResolved = true;
+		}
+	}
+}
 
-		// TODO lib a (lazy) --> all its dependencies must be lazy
-		// input
-		// a -> b (lazy) -> c
-		// output
-		// a -> b (lazy), c (lazy)
+// TODO add childResolved to resolved
+// TODO check cacles
 
 
-		// a -> c, b (lazy)
-		// b -> c (lazy)
+// TODO lib a (lazy) --> all its dependencies must be lazy
+// input
+// a -> b (lazy) -> c
+// output
+// a -> b (lazy), c (lazy)
 
 
-		// a -> c, b (lazy)
+// a -> c, b (lazy)
+// b -> c (lazy)
 
 
-		// a -> c (lazy), b (lazy)
-		// b -> c
+// a -> c, b (lazy)
 
-		// kette gewinnt lazy --> alle dependencies von einer lazy dep sind auch lazy
-		// merge gewinnt eager
 
+// a -> c (lazy), b (lazy)
+// b -> c
 
-		// TODO put this into a classes to better structure the code
-		// TODO instead of using a "global" map, have a Dependency as a class with a name
-		// and the functionality to resolve its dependencies
-		// ManifestHints -> resolve
-	});
+// kette gewinnt lazy --> alle dependencies von einer lazy dep sind auch lazy
+// merge gewinnt eager
 
-	libraryInfosMap.set(libName, mergedDependencies);
 
+// TODO put this into a classes to better structure the code
+// TODO instead of using a "global" map, have a Dependency as a class with a name
+// and the functionality to resolve its dependencies
+// ManifestHints -> resolve
 
-	return mergedDependencies;
-};
 
 /**
  * Sorts the keys of a given object
@@ -221,21 +236,41 @@ const sortObjectKeys = (obj) => {
 	return sortedObject;
 };
 
+/**
+ *
+ * @param {object} result
+ * @param {DependencyInfo} libs
+ */
 const addManifestHints = (result, libs) => {
-	if (Object.keys(libs).length) {
-		const sortedLibs = sortObjectKeys(libs);
+	if (libs.libs.length) {
+		// const sortedLibs = sortObjectKeys(libs.libs);
+		const libsObject = {};
+		libs.libs.forEach((sortedLib) => {
+			libsObject[sortedLib.name] = {};
+			if (sortedLib.lazy) {
+				libsObject[sortedLib.name].lazy = true;
+			}
+		});
 		result.manifestHints = {
 			dependencies: {
-				libs: sortedLibs
+				libs: libsObject
 			}
 		};
 	}
 };
 
+const convertToDependencyInfoObjects = (libs) => {
+	return Object.keys(libs).map((name) => {
+		const lazy = libs[name].lazy === true;
+		return new DependencyInfoObject(name, lazy);
+	});
+};
+
 const processLibraryInfo = async (libraryInfo, dependencyInfoMap, embeddedInfoMap) => {
 	const manifestInfo = await processManifest(libraryInfo.mainManifest);
 	// gather shallow library information
-	dependencyInfoMap.set(libraryInfo.name, manifestInfo.libs);
+	const dependencyInfoObjects = convertToDependencyInfoObjects(manifestInfo.libs);
+	dependencyInfoMap.set(libraryInfo.name, new DependencyInfo(dependencyInfoObjects));
 	const embeds = manifestInfo.embeds; // sdk
 	// filter
 	const embeddedPaths = embeds.map((embed) => {
@@ -249,7 +284,8 @@ const processLibraryInfo = async (libraryInfo, dependencyInfoMap, embeddedInfoMa
 	// get all embedded manifests
 	const embeddedManifestPromises = relevantManifests.map(async (relevantManifest) => {
 		const result = await processManifest(relevantManifest);
-		dependencyInfoMap.set(result.id, result.libs);
+		const dependencyInfoObjects = convertToDependencyInfoObjects(result.libs);
+		dependencyInfoMap.set(result.id, new DependencyInfo(dependencyInfoObjects));
 		embeddedInfoMap.set(result.id, {
 			library: libraryInfo.name
 		});
@@ -298,7 +334,7 @@ module.exports = async function({options}) {
 	 *  }
 	 * }
 	 *
-	 * @type {Map<string, DependencyInfos>}
+	 * @type {Map<string, DependencyInfo>}
 	 */
 	const dependencyInfoMap = new Map();
 	const embeddedInfoMap = new Map();