@ts-for-gir/cli 4.0.0-beta.2 → 4.0.0-beta.21

package/src/module-loader.ts

@@ -2,12 +2,11 @@
  * The ModuleLoader is used for reading gir modules from the file system and to solve conflicts (e.g. Gtk-3.0 and Gtk-4.0 would be a conflict)
  */
 
-import inquirer, { ListQuestion, Answers } from 'inquirer'
-import glob from 'tiny-glob'
-import { basename } from 'path'
-import { readFile } from 'fs/promises'
+import { type Question } from 'inquirer'
+import { select } from '@inquirer/prompts'
+import { glob } from 'glob'
+import { basename, join } from 'path'
 import { bold } from 'colorette'
-import { parser } from '@gi.ts/parser'
 import {
     DependencyManager,
     ResolveType,
@@ -22,7 +21,7 @@ import { Config } from './config.js'
 
 import type {
     GirModulesGroupedMap,
-    GenerateConfig,
+    OptionsGeneration,
     GirModuleResolvedBy,
     GirModulesGrouped,
     DependencyMap,
@@ -35,7 +34,7 @@ export class ModuleLoader {
     dependencyManager: DependencyManager
     /** Transitive module dependencies */
     modDependencyMap: DependencyMap = {}
-    constructor(protected readonly config: GenerateConfig) {
+    constructor(protected readonly config: OptionsGeneration) {
         this.log = new Logger(config.verbose, 'ModuleLoader')
         this.dependencyManager = DependencyManager.getInstance(config)
     }
@@ -109,49 +108,56 @@ export class ModuleLoader {
     protected generateContinueQuestion(
         message = `do you want to continue?`,
         choices = ['Yes', 'Go back'],
-    ): ListQuestion {
-        const question: ListQuestion = {
-            name: 'continue',
+    ): { message: string; choices: string[] } {
+        return {
             message,
-            type: 'list',
             choices,
         }
-        return question
     }
 
     protected generateIgnoreDepsQuestion(
         message = `Do you want to ignore them too?`,
         choices = ['Yes', 'No', 'Go back'],
-    ): ListQuestion {
-        const question: ListQuestion = {
-            name: 'continue',
+    ): { message: string; choices: string[] } {
+        return {
             message,
-            type: 'list',
             choices,
         }
-        return question
     }
 
     protected async askIgnoreDepsPrompt(
         deps: GirModuleResolvedBy[] | Set<GirModuleResolvedBy>,
     ): Promise<'Yes' | 'No' | 'Go back'> {
-        let question: ListQuestion<Answers> | null = null
         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'))
-            question = this.generateIgnoreDepsQuestion()
-        } else {
-            this.log.log(bold('\nNo dependencies found on the ignored modules'))
-            question = this.generateContinueQuestion()
+
+            // 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' },
+                ],
+            })
         }
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const answer: string = (await inquirer.prompt([question])).continue
-        return answer as 'Yes' | 'No' | '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' },
+            ],
+        })
     }
 
     /**
@@ -159,16 +165,16 @@ export class ModuleLoader {
      * @param girModuleGrouped
      * @param message
      */
-    protected generateModuleVersionQuestion(girModuleGrouped: GirModulesGrouped, message?: string): ListQuestion {
+    protected generateModuleVersionQuestion(girModuleGrouped: GirModulesGrouped, message?: string): Question {
         message = message || `Multiple versions of '${girModuleGrouped.namespace}' found, which one do you want to use?`
         const choices = ['All', ...girModuleGrouped.modules.map((module) => module.packageName)]
-        const question: ListQuestion = {
+
+        return {
             name: girModuleGrouped.namespace,
             message,
             type: 'list',
             choices,
         }
-        return question
     }
 
     /**
@@ -176,7 +182,7 @@ export class ModuleLoader {
      * @param girModulesGroupedMap
      * @param packageName
      */
-    protected findPackageNamesDependOnPackage(
+    protected findGirFilesDependOnPackage(
         girModulesGroupedMap: GirModulesGroupedMap,
         packageName: string,
     ): GirModuleResolvedBy[] {
@@ -201,28 +207,27 @@ export class ModuleLoader {
      * @param girModulesGroupedMap
      * @param packageName
      */
-    protected findPackageNamesDependOnPackages(
+    protected findGirFilesDependOnPackages(
         girModulesGroupedMap: GirModulesGroupedMap,
         packageNames: string[],
     ): GirModuleResolvedBy[] {
         let girModules: GirModuleResolvedBy[] = []
         for (const packageName of packageNames) {
-            girModules = girModules.concat(this.findPackageNamesDependOnPackage(girModulesGroupedMap, packageName))
+            girModules = [...girModules, ...this.findGirFilesDependOnPackage(girModulesGroupedMap, packageName)]
         }
         return girModules
     }
 
     protected async askForVersionsPrompt(girModulesGrouped: GirModulesGrouped): Promise<AnswerVersion> {
-        const question = this.generateModuleVersionQuestion(girModulesGrouped)
-        const choices = question.choices as string[]
-        if (!choices) {
-            throw new Error('No valid questions!')
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const selected: string = (await inquirer.prompt([question]))[girModulesGrouped.namespace]
-        if (!selected) {
-            throw new Error('No valid answer!')
-        }
+        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 {
@@ -231,10 +236,9 @@ export class ModuleLoader {
             }
         }
 
-        const unselected = choices.filter((choice) => choice !== selected)
         return {
             selected: [selected],
-            unselected,
+            unselected: choices.filter((choice) => choice !== selected && choice !== 'All'),
         }
     }
 
@@ -270,10 +274,7 @@ export class ModuleLoader {
                 while (goBack) {
                     versionAnswer = await this.askForVersionsPrompt(girModulesGrouped)
                     // Check modules that depend on the unchosen modules
-                    wouldIgnoreDeps = this.findPackageNamesDependOnPackages(
-                        girModulesGroupedMap,
-                        versionAnswer.unselected,
-                    )
+                    wouldIgnoreDeps = this.findGirFilesDependOnPackages(girModulesGroupedMap, versionAnswer.unselected)
                     // Do not check dependencies that have already been ignored
                     wouldIgnoreDeps = wouldIgnoreDeps.filter((dep) => !ignore.includes(dep.packageName))
                     ignoreDepsAnswer = await this.askIgnoreDepsPrompt(wouldIgnoreDeps)
@@ -314,19 +315,15 @@ export class ModuleLoader {
      * @param ignoredModules
      */
     protected async askAddToIgnoreToConfigPrompt(ignoredModules: string[] | Set<string>): Promise<void> {
-        const questions = [
-            {
-                name: 'addToIgnore',
-                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: '${Config.configFilePath}`,
-                type: 'list',
-                choices: ['No', 'Yes'],
-            },
-        ]
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const answer: { [name: string]: string } = await inquirer.prompt(questions)
-
-        if (answer.addToIgnore === 'Yes') {
+        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: '${Config.configFilePath}'`,
+            choices: [
+                { value: 'No', name: 'No' },
+                { value: 'Yes', name: 'Yes' },
+            ],
+        })
+
+        if (shouldAdd === 'Yes') {
             await Config.addToConfig({
                 ignore: Array.from(ignoredModules),
             })
@@ -356,7 +353,7 @@ export class ModuleLoader {
      * @param girModule
      */
     protected extendDependencyMapByGirModule(girModule: GirModule): void {
-        this.modDependencyMap[girModule.packageName] = girModule.dependencies
+        this.modDependencyMap[girModule.packageName] = girModule.dependencies!
     }
 
     /**
@@ -364,11 +361,11 @@ export class ModuleLoader {
      * is required so that all dependencies can be found internally when generating the dependency imports for the module .d.ts file
      * @param girModules
      */
-    protected setTraverseDependenciesForModules(girModules: GirModuleResolvedBy[]): void {
+    protected async initGirModules(girModules: GirModuleResolvedBy[]): Promise<void> {
         for (const girModule of girModules) {
             const result: { [name: string]: Dependency } = {}
             this.traverseDependencies(girModule.packageName, result)
-            girModule.module.transitiveDependencies = Object.values(result)
+            await girModule.module.initTransitiveDependencies(Object.values(result))
         }
     }
 
@@ -383,10 +380,8 @@ export class ModuleLoader {
             return null
         }
 
-        this.log.log(`Parsing ${dependency.path}...`)
-        const fileContents = await readFile(dependency.path, 'utf8')
-        const result = parser.parseGir(fileContents)
-        const girModule = GirModule.load(result, this.config, this.dependencyManager)
+        this.log.log(`Loading ${dependency.packageName}...`)
+        const girModule = await GirModule.load(dependency, this.config, this.dependencyManager)
         // Figure out transitive module dependencies
         this.extendDependencyMapByGirModule(girModule)
         return girModule
@@ -451,6 +446,7 @@ export class ModuleLoader {
                         packageName: girModule.packageName,
                         module: girModule,
                         resolvedBy,
+                        path: dependency.path,
                     }
                     girModules.push(addModule)
                     newModuleFound = true
@@ -466,21 +462,13 @@ export class ModuleLoader {
         }
 
         // Figure out transitive module dependencies
-        this.setTraverseDependenciesForModules(girModules)
+        await this.initGirModules(girModules)
 
         // Load girModules for dependencies
         for (const girModule of girModules) {
             // Load dependencies
             const transitiveDependencies = girModule.module.transitiveDependencies
             if (transitiveDependencies.length > 0) {
-                for (const transitiveDependency of transitiveDependencies) {
-                    if (ignoreDependencies.includes(transitiveDependency.packageName)) {
-                        this.log.warn(
-                            `Load dependency "${transitiveDependency.packageName}" which is in the ignore list, if this should really be ignored also ignore "${girModule.packageName}"`,
-                        )
-                    }
-                }
-
                 await this.loadGirModules(
                     transitiveDependencies,
                     ignoreDependencies,
@@ -490,6 +478,7 @@ export class ModuleLoader {
                 )
             }
         }
+
         return {
             loaded: girModules,
             failed: failedGirModules,
@@ -501,60 +490,53 @@ export class ModuleLoader {
      * @param modules
      * @param ignore
      */
-    protected async findPackageNames(modules: string[], ignore: string[] = []): Promise<Set<string>> {
-        const foundModules = new Set<string>()
-
-        for (let i = 0; i < modules.length; i++) {
-            if (modules[i]) {
-                const filename = `${modules[i]}.gir`
-                let files: string[] = []
-                for (const girDirectory of this.config.girDirectories) {
-                    try {
-                        files = files.concat(await glob(filename, { cwd: girDirectory }))
-                    } catch (error) {
-                        this.log.warn(`Error on finding "${filename}" in "${girDirectory}"`, error)
-                    }
-                }
+    protected async findGirFiles(globPackageNames: string[], ignore: string[] = []): Promise<Set<string>> {
+        const foundFiles = new Set<string>()
 
-                let globModules = files.map((file) => basename(file, '.gir'))
-                // Filter out the ignored modules
-                globModules = globModules.filter((mod) => {
-                    const isIgnored = ignore.includes(mod)
-                    if (isIgnored) {
-                        this.log.warn(`Ignore ${mod}`)
-                    }
-                    return !isIgnored
-                })
-                globModules.forEach((mod) => foundModules.add(mod))
+        for (let i = 0; i < globPackageNames.length; i++) {
+            if (!globPackageNames[i]) {
+                continue
             }
+            const filename = `${globPackageNames[i]}.gir`
+            const pattern = this.config.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 foundModules
+
+        return foundFiles
     }
 
-    protected packageNamesToDependencies(packageNames: Set<string>): Dependency[] {
-        return Array.from(packageNames).map((packageName) => {
+    protected 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)
-            return this.dependencyManager.get(namespace, version)
-        })
+            const dep = await this.dependencyManager.get(namespace, version)
+            dependencies.push(dep)
+        }
+
+        return dependencies
     }
 
     /**
-     * Loads all found `packageNames` and sorts out those that the user does not want to use including their dependencies
+     * Loads all found `packageNames`
      * @param girDirectories
      * @param packageNames
+     * @param doNotAskForVersionOnConflict Set this to false if you want to get a prompt for each version conflict
      */
     public async getModulesResolved(
         packageNames: string[],
         ignore: string[] = [],
         doNotAskForVersionOnConflict = true,
     ): Promise<{ keep: GirModuleResolvedBy[]; grouped: GirModulesGroupedMap; ignore: string[]; failed: Set<string> }> {
-        const foundPackageNames = await this.findPackageNames([...packageNames], ignore)
+        const girFiles = await this.findGirFiles([...packageNames], ignore)
         // Always require these because GJS does...
-        const GLib = this.dependencyManager.get('GLib', '2.0')
-        const Gio = this.dependencyManager.get('Gio', '2.0')
-        const GObject = this.dependencyManager.get('GObject', '2.0')
+        const GLib = await this.dependencyManager.get('GLib', '2.0')
+        const Gio = await this.dependencyManager.get('Gio', '2.0')
+        const GObject = await this.dependencyManager.get('GObject', '2.0')
 
-        const dependencies = this.packageNamesToDependencies(foundPackageNames)
+        const dependencies = await this.girFilePathToDependencies(girFiles)
 
         const { loaded, failed } = await this.loadGirModules(
             [
@@ -582,7 +564,7 @@ export class ModuleLoader {
     }
 
     /**
-     * Find modules with the possibility to use wild cards for module names. E.g. `Gtk*` or `'*'`
+     * Find modules
      * @param girDirectories
      * @param modules
      */
@@ -590,10 +572,17 @@ export class ModuleLoader {
         modules: string[],
         ignore: string[] = [],
     ): Promise<{ grouped: GirModulesGroupedMap; loaded: GirModuleResolvedBy[]; failed: string[] }> {
-        const foundPackageNames = await this.findPackageNames(modules, ignore)
-        const dependencies = this.packageNamesToDependencies(foundPackageNames)
+        const girFiles = await this.findGirFiles(modules, ignore)
+        const dependencies = await this.girFilePathToDependencies(girFiles)
         const { loaded, failed } = await this.loadGirModules(dependencies, ignore)
         const grouped = this.groupGirFiles(loaded)
         return { grouped, loaded, failed: Array.from(failed) }
     }
+
+    /** Start parsing the gir modules */
+    public parse(girModules: GirModuleResolvedBy[]): void {
+        for (const girModule of girModules) {
+            girModule.module.parse()
+        }
+    }
 }

package/src/start.ts

@@ -2,7 +2,7 @@
 import yargs from 'yargs'
 import { hideBin } from 'yargs/helpers'
 
-import { generate, list, doc } from './commands/index.js'
+import { generate, list, doc, copy } from './commands/index.js'
 import { Config } from './config.js'
 
 void yargs(hideBin(process.argv))
@@ -11,6 +11,7 @@ void yargs(hideBin(process.argv))
     .usage(Config.usage)
     .command(generate.command, generate.description, generate.builder, generate.handler)
     .command(list.command, list.description, list.builder, list.handler)
+    .command(copy.command, copy.description, copy.builder, copy.handler)
     .command(doc.command, doc.description, doc.builder, doc.handler)
     .demandCommand(1)
     .help().argv