@ts-for-gir/cli 4.0.0-beta.25 → 4.0.0-beta.26

package/src/module-loader/dependency-resolver.ts

@@ -0,0 +1,100 @@
+/**
+ * Handles dependency resolution and traversal for GIR modules
+ */
+
+import type { Dependency, DependencyMap, GirModule, GirModuleResolvedBy, GirModulesGroupedMap } from "@ts-for-gir/lib";
+import { isIterable } from "@ts-for-gir/lib";
+
+export class DependencyResolver {
+	private modDependencyMap: DependencyMap = {};
+
+	/**
+	 * Extends the modDependencyMap by the current Module,
+	 * should be called for each girModule so that the modDependencyMap is complete
+	 */
+	extendDependencyMapByGirModule(girModule: GirModule): void {
+		this.modDependencyMap[girModule.packageName] = girModule.dependencies || [];
+	}
+
+	/**
+	 * Figure out transitive module dependencies
+	 */
+	traverseDependencies(packageName: string, result: { [name: string]: Dependency } = {}): void {
+		const deps = this.modDependencyMap[packageName];
+		if (isIterable(deps)) {
+			for (const dep of deps) {
+				if (result[dep.packageName]) continue;
+				result[dep.packageName] = dep;
+				this.traverseDependencies(dep.packageName, result);
+			}
+		}
+	}
+
+	/**
+	 * Get transitive dependencies for a package
+	 */
+	getTransitiveDependencies(packageName: string): Dependency[] {
+		const result: { [name: string]: Dependency } = {};
+		this.traverseDependencies(packageName, result);
+		return Object.values(result);
+	}
+
+	/**
+	 * Find modules that depend on the module with the name 'packageName'
+	 */
+	findModulesDependingOnPackage(
+		girModulesGroupedMap: GirModulesGroupedMap,
+		packageName: string,
+	): GirModuleResolvedBy[] {
+		const girModules: GirModuleResolvedBy[] = [];
+
+		for (const girModulesGrouped of Object.values(girModulesGroupedMap)) {
+			for (const girModuleResolvedBy of girModulesGrouped.modules) {
+				if (girModuleResolvedBy.packageName === packageName) {
+					continue;
+				}
+				for (const dep of girModuleResolvedBy.module.dependencies) {
+					if (dep.packageName === packageName && !girModules.includes(girModuleResolvedBy)) {
+						girModules.push(girModuleResolvedBy);
+					}
+				}
+			}
+		}
+
+		return girModules;
+	}
+
+	/**
+	 * Find modules that depend on the modules with the names in `packageNames`
+	 */
+	findModulesDependingOnPackages(
+		girModulesGroupedMap: GirModulesGroupedMap,
+		packageNames: string[],
+	): GirModuleResolvedBy[] {
+		let girModules: GirModuleResolvedBy[] = [];
+
+		for (const packageName of packageNames) {
+			girModules = [...girModules, ...this.findModulesDependingOnPackage(girModulesGroupedMap, packageName)];
+		}
+
+		return girModules;
+	}
+
+	/**
+	 * Returns a girModule found by `packageName` property
+	 */
+	findGirModuleByFullNames(
+		girModules: (GirModuleResolvedBy | GirModule)[],
+		packageNames: string[],
+	): Array<GirModuleResolvedBy | GirModule> {
+		return girModules.filter((girModule) => packageNames.includes(girModule.packageName));
+	}
+
+	/**
+	 * Checks if a girModules with the `packageNames` exists
+	 */
+	existsGirModules(girModules: (GirModuleResolvedBy | GirModule)[], packageName: string): boolean {
+		const foundModule = this.findGirModuleByFullNames(girModules, [packageName]);
+		return foundModule.length > 0;
+	}
+}

package/src/module-loader/file-finder.ts

@@ -0,0 +1,56 @@
+/**
+ * Handles finding GIR files in the filesystem
+ */
+
+import { basename, join } from "node:path";
+import type { Dependency, DependencyManager } from "@ts-for-gir/lib";
+import { splitModuleName } from "@ts-for-gir/lib";
+import { glob } from "glob";
+
+export class FileFinder {
+	constructor(
+		private readonly girDirectories: string[],
+		private readonly dependencyManager: DependencyManager,
+	) {}
+
+	/**
+	 * Find modules with the possibility to use wild cards for module names. E.g. `Gtk*` or `'*'`
+	 * @param globPackageNames Module names with potential wildcards
+	 * @param ignore Modules to ignore
+	 */
+	async findGirFiles(globPackageNames: string[], ignore: string[] = []): Promise<Set<string>> {
+		const foundFiles = new Set<string>();
+
+		for (let i = 0; i < globPackageNames.length; i++) {
+			if (!globPackageNames[i]) {
+				continue;
+			}
+
+			const filename = `${globPackageNames[i]}.gir`;
+			const pattern = this.girDirectories.map((girDirectory) => join(girDirectory, filename));
+			const ignoreGirs = ignore.map((girDirectory) => `${girDirectory}.gir`);
+			const files = await glob(pattern, { ignore: ignoreGirs });
+
+			files.forEach((file) => foundFiles.add(file));
+		}
+
+		return foundFiles;
+	}
+
+	/**
+	 * Convert GIR file paths to Dependency objects
+	 * @param girFiles Set of GIR file paths
+	 */
+	async girFilePathToDependencies(girFiles: Set<string>): Promise<Dependency[]> {
+		const dependencies: Dependency[] = [];
+
+		for (const girFile of girFiles) {
+			const packageName = basename(girFile, ".gir");
+			const { namespace, version } = splitModuleName(packageName);
+			const dep = await this.dependencyManager.get(namespace, version);
+			dependencies.push(dep);
+		}
+
+		return dependencies;
+	}
+}

package/src/module-loader/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Module loader components exports
+ */
+
+export { DependencyResolver } from "./dependency-resolver.ts";
+export { FileFinder } from "./file-finder.ts";
+export { ModuleGrouper } from "./module-grouper.ts";
+export { PromptHandler } from "./prompt-handler.ts";

package/src/module-loader/module-grouper.ts

@@ -0,0 +1,77 @@
+/**
+ * Handles grouping of GIR modules and conflict resolution
+ */
+
+import type { GirModuleResolvedBy, GirModulesGrouped, GirModulesGroupedMap } from "@ts-for-gir/lib";
+import { splitModuleName } from "@ts-for-gir/lib";
+
+export class ModuleGrouper {
+	/**
+	 * Groups Gir modules by name id
+	 * E.g. Gtk-3.0 and Gtk-4.0 will be grouped
+	 */
+	groupGirFiles(resolveGirModules: Set<GirModuleResolvedBy> | GirModuleResolvedBy[]): GirModulesGroupedMap {
+		const girModulesGrouped: GirModulesGroupedMap = {};
+
+		for (const resolveGirModule of resolveGirModules) {
+			const { namespace } = splitModuleName(resolveGirModule.packageName);
+			const id = namespace.toLowerCase();
+
+			if (!girModulesGrouped[id]) {
+				girModulesGrouped[id] = {
+					namespace: namespace,
+					modules: [resolveGirModule],
+					hasConflict: false,
+				};
+			} else {
+				girModulesGrouped[id].modules.push(resolveGirModule);
+				girModulesGrouped[id].hasConflict = true;
+			}
+		}
+
+		return girModulesGrouped;
+	}
+
+	/**
+	 * Sorts out the module the user has not selected via cli prompt
+	 * @param girModulesGrouped Grouped modules
+	 * @param selected Users selected module packageName
+	 */
+	sortVersionsByAnswer(
+		girModulesGrouped: GirModulesGrouped,
+		selected: string[],
+	): { keep: Set<GirModuleResolvedBy>; ignore: string[] } {
+		const keep = new Set<GirModuleResolvedBy>();
+		let ignore: string[] = [];
+
+		if (!girModulesGrouped.hasConflict) {
+			keep.add(girModulesGrouped.modules[0]);
+		} else {
+			const keepModules = this.findGirModuleByFullNames(girModulesGrouped.modules, selected);
+			const girModulePackageNames = girModulesGrouped.modules.map((resolveGirModule) => resolveGirModule.packageName);
+
+			if (!keepModules || keepModules.length <= 0) {
+				throw new Error("Module not found!");
+			}
+
+			for (const keepModule of keepModules) {
+				keep.add(keepModule);
+			}
+
+			const toIgnore = girModulePackageNames.filter((packageName) => !selected.includes(packageName));
+			ignore = ignore.concat(toIgnore);
+		}
+
+		return {
+			keep,
+			ignore,
+		};
+	}
+
+	/**
+	 * Find modules by package names
+	 */
+	private findGirModuleByFullNames(girModules: GirModuleResolvedBy[], packageNames: string[]): GirModuleResolvedBy[] {
+		return girModules.filter((girModule) => packageNames.includes(girModule.packageName));
+	}
+}

package/src/module-loader/prompt-handler.ts

@@ -0,0 +1,111 @@
+/**
+ * Handles CLI prompts for module version conflicts and ignored modules
+ */
+
+import { select } from "@inquirer/prompts";
+import type { AnswerVersion, GirModuleResolvedBy, GirModulesGrouped } from "@ts-for-gir/lib";
+import { Logger } from "@ts-for-gir/lib";
+import { bold } from "colorette";
+import { addToConfig, configFilePath } from "../config.ts";
+
+export class PromptHandler {
+	private readonly log: Logger;
+
+	constructor(verbose: boolean) {
+		this.log = new Logger(verbose, "PromptHandler");
+	}
+
+	/**
+	 * Ask if user wants to ignore dependencies
+	 */
+	async askIgnoreDepsPrompt(deps: GirModuleResolvedBy[] | Set<GirModuleResolvedBy>): Promise<"Yes" | "No" | "Go back"> {
+		const size = (deps as GirModuleResolvedBy[]).length || (deps as Set<GirModuleResolvedBy>).size || 0;
+
+		if (size > 0) {
+			// Show dependencies that would be ignored
+			this.log.log(bold("\nThe following modules have the ignored modules as dependencies:"));
+			for (const dep of deps) {
+				this.log.log(`- ${dep.packageName}`);
+			}
+			this.log.log(bold("\n"));
+
+			// Ask if user wants to ignore these dependencies
+			return select<"Yes" | "No" | "Go back">({
+				message: "Do you want to ignore them too?",
+				choices: [
+					{ value: "Yes", name: "Yes" },
+					{ value: "No", name: "No" },
+					{ value: "Go back", name: "Go back" },
+				],
+			});
+		}
+
+		// No dependencies found
+		this.log.log(bold("\nNo dependencies found on the ignored modules"));
+		return select<"Yes" | "Go back">({
+			message: "Do you want to continue?",
+			choices: [
+				{ value: "Yes", name: "Yes" },
+				{ value: "Go back", name: "Go back" },
+			],
+		});
+	}
+
+	/**
+	 * Ask for module version selection
+	 */
+	async askForVersionsPrompt(girModulesGrouped: GirModulesGrouped): Promise<AnswerVersion> {
+		const choices = ["All", ...girModulesGrouped.modules.map((module) => module.packageName)];
+
+		const selected = await select<string>({
+			message: `Multiple versions of '${girModulesGrouped.namespace}' found, which one do you want to use?`,
+			choices: choices.map((choice) => ({
+				value: choice,
+				name: choice,
+			})),
+		});
+
+		if (selected === "All") {
+			return {
+				selected: choices.filter((choice) => choice !== "All"),
+				unselected: [],
+			};
+		}
+
+		return {
+			selected: [selected],
+			unselected: choices.filter((choice) => choice !== selected && choice !== "All"),
+		};
+	}
+
+	/**
+	 * Ask if user wants to add ignored modules to config
+	 */
+	async askAddToIgnoreToConfigPrompt(ignoredModules: string[] | Set<string>): Promise<void> {
+		const shouldAdd = await select<"Yes" | "No">({
+			message: `Do you want to add the ignored modules to your config so that you don't need to select them again next time?\n  Config path: '${configFilePath}'`,
+			choices: [
+				{ value: "No", name: "No" },
+				{ value: "Yes", name: "Yes" },
+			],
+		});
+
+		if (shouldAdd === "Yes") {
+			await addToConfig({
+				ignore: Array.from(ignoredModules),
+			});
+			this.log.log(`Add ignored modules to '${configFilePath}'`);
+		}
+	}
+
+	/**
+	 * Show ignored modules
+	 */
+	showIgnoredModules(ignore: string[]): void {
+		if (ignore && ignore.length > 0) {
+			const ignoreLogList = `- ${ignore.join("\n- ")}`;
+			this.log.log(bold("\n The following modules will be ignored:"));
+			this.log.log(`\n${ignoreLogList}\n`);
+		}
+	}
+}