@ts-for-gir/cli 3.3.0 → 4.0.0-beta.10

package/src/generation-handler.ts

@@ -12,16 +12,17 @@ import { GeneratorType, Generator } from '@ts-for-gir/generator-base'
 import { TypeDefinitionGenerator } from '@ts-for-gir/generator-typescript'
 import { HtmlDocGenerator } from '@ts-for-gir/generator-html-doc'
 
-import type { InheritanceTable, GenerateConfig, GirModulesGrouped } from '@ts-for-gir/lib'
+import type { OptionsGeneration, NSRegistry } from '@ts-for-gir/lib'
 
 export class GenerationHandler {
     log: Logger
     generator: Generator
+
     constructor(
-        private readonly config: GenerateConfig,
+        private readonly config: OptionsGeneration,
         type: GeneratorType,
     ) {
-        this.log = new Logger(config.environment, config.verbose, 'GenerationHandler')
+        this.log = new Logger(config.verbose, 'GenerationHandler')
 
         switch (type) {
             case GeneratorType.TYPES:
@@ -35,46 +36,35 @@ export class GenerationHandler {
         }
     }
 
-    private finalizeInheritance(inheritanceTable: InheritanceTable): void {
-        for (const clsName of Object.keys(inheritanceTable)) {
-            let p: string | string[] = inheritanceTable[clsName][0]
-            while (p) {
-                p = inheritanceTable[p]
-                if (p) {
-                    p = p[0]
-                    inheritanceTable[clsName].push(p)
-                }
-            }
-        }
-    }
-
-    public async start(girModules: GirModule[], girModulesGrouped: GirModulesGrouped[]): Promise<void> {
-        this.log.info(START_MODULE(this.config.environment, this.config.buildType))
+    public async start(girModules: GirModule[], registry: NSRegistry): Promise<void> {
+        this.log.info(START_MODULE)
 
         if (girModules.length == 0) {
             this.log.error(ERROR_NO_MODULE_SPECIFIED)
         }
 
-        GirModule.allGirModules = girModules
-
         this.log.info(FILE_PARSING_DONE)
 
-        const inheritanceTable: InheritanceTable = {}
-        for (const girModule of girModules) girModule.init(inheritanceTable)
+        this.log.info(TSDATA_PARSING_DONE)
+
+        if (this.config.outdir) {
+            await mkdir(this.config.outdir, { recursive: true })
+        }
 
-        this.finalizeInheritance(inheritanceTable)
+        // TODO: Put this somewhere that makes sense
+        registry.transform({
+            inferGenerics: true,
+            verbose: this.config.verbose,
+        })
 
-        this.log.info(TSDATA_PARSING_DONE)
+        await this.generator.start(registry)
 
         for (const girModule of girModules) {
-            if (this.config.outdir) {
-                await mkdir(this.config.outdir, { recursive: true })
-            }
             this.log.log(` - ${girModule.packageName} ...`)
-            girModule.start(girModules)
+            await this.generator.generate(registry, girModule)
         }
 
-        await this.generator.start(girModules, girModulesGrouped, inheritanceTable)
+        await this.generator.finish(registry, girModules)
 
         this.log.success(GENERATING_TYPES_DONE)
     }

package/src/module-loader.ts

@@ -3,9 +3,8 @@
  */
 
 import inquirer, { ListQuestion, Answers } from 'inquirer'
-import glob from 'tiny-glob'
-import { basename } from 'path'
-import { readFile } from 'fs/promises'
+import { glob } from 'glob'
+import { basename, join } from 'path'
 import { bold } from 'colorette'
 import {
     DependencyManager,
@@ -15,14 +14,13 @@ import {
     splitModuleName,
     union,
     isIterable,
-    girParser,
     WARN_NO_GIR_FILE_FOUND_FOR_PACKAGE,
 } from '@ts-for-gir/lib'
 import { Config } from './config.js'
 
 import type {
     GirModulesGroupedMap,
-    GenerateConfig,
+    OptionsGeneration,
     GirModuleResolvedBy,
     GirModulesGrouped,
     DependencyMap,
@@ -35,8 +33,8 @@ export class ModuleLoader {
     dependencyManager: DependencyManager
     /** Transitive module dependencies */
     modDependencyMap: DependencyMap = {}
-    constructor(protected readonly config: GenerateConfig) {
-        this.log = new Logger('', config.verbose, 'ModuleLoader')
+    constructor(protected readonly config: OptionsGeneration) {
+        this.log = new Logger(config.verbose, 'ModuleLoader')
         this.dependencyManager = DependencyManager.getInstance(config)
     }
 
@@ -176,7 +174,7 @@ export class ModuleLoader {
      * @param girModulesGroupedMap
      * @param packageName
      */
-    protected findPackageNamesDependOnPackage(
+    protected findGirFilesDependOnPackage(
         girModulesGroupedMap: GirModulesGroupedMap,
         packageName: string,
     ): GirModuleResolvedBy[] {
@@ -201,13 +199,13 @@ 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
     }
@@ -270,10 +268,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)
@@ -356,7 +351,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 +359,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 +378,8 @@ export class ModuleLoader {
             return null
         }
 
-        this.log.log(`Parsing ${dependency.path}...`)
-        const fileContents = await readFile(dependency.path, 'utf8')
-        const result = girParser(fileContents)
-        const girModule = new GirModule(result, this.config)
+        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 +444,7 @@ export class ModuleLoader {
                         packageName: girModule.packageName,
                         module: girModule,
                         resolvedBy,
+                        path: dependency.path,
                     }
                     girModules.push(addModule)
                     newModuleFound = true
@@ -466,21 +460,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 +476,7 @@ export class ModuleLoader {
                 )
             }
         }
+
         return {
             loaded: girModules,
             failed: failedGirModules,
@@ -501,56 +488,65 @@ 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 dependencies = this.packageNamesToDependencies(foundPackageNames)
-        const { loaded, failed } = await this.loadGirModules(dependencies, ignore)
+        const girFiles = await this.findGirFiles([...packageNames], ignore)
+        // Always require these because GJS does...
+        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 = await this.girFilePathToDependencies(girFiles)
+
+        const { loaded, failed } = await this.loadGirModules(
+            [
+                GLib,
+                Gio,
+                GObject,
+                ...dependencies.filter(
+                    (dep) => dep.namespace !== 'GLib' && dep.namespace !== 'Gio' && dep.namespace !== 'GObject',
+                ),
+            ],
+            ignore,
+        )
         let keep: GirModuleResolvedBy[] = []
         if (doNotAskForVersionOnConflict) {
             keep = loaded
@@ -566,7 +562,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
      */
@@ -574,10 +570,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