Replaced default remote repo provider

- GitHub API can be choosed using --provider github variable - Default API - Forgejo - GenerateCommand can be modified through custom EventProviderGenerator
hhru · Jan 13, 2025 · 5de9a73 · 5de9a73
1 parent 0d33992
commit 5de9a73
Show file tree

Hide file tree

Showing 22 changed files with 367 additions and 97 deletions.
diff --git a/Sources/AnalyticsGen/Commands/GenerateCommand.swift b/Sources/AnalyticsGen/Commands/GenerateCommand.swift
@@ -1,3 +1,4 @@
+import DictionaryCoder
 import Foundation
 import SwiftCLI
 import PromiseKit
@@ -31,22 +32,42 @@ final class GenerateCommand: AsyncExecutableCommand {
         "--debug",
         description: "Enable debug logging."
     )
+
+    let provider = Key<String>(
+        "--provider",
+        "-p",
+        description: "Enter custom remote repository provider. Default - Forgejo"
+    )
 
-    let generator: EventGenerator
-
-    // MARK: - Initializers
-
-    init(generator: EventGenerator) {
-        self.generator = generator
+    var generator: EventGenerator?
+    let dependeciesGenerator: DependenciesGenerator
+
+    init(
+        dependeciesGenerator: DependenciesGenerator = DefaultDependeciesGenerator()
+    ) {
+        self.dependeciesGenerator = dependeciesGenerator
     }
 
     // MARK: - AsyncExecutableCommand
 
     func executeAsyncAndExit() throws {
+
         let configurationPath = self.configurationPath.value ?? .defaultConfigurationPath
-
+
+        let selectedRemoteRepoProvider = self.provider.value ?? .defaultRemoteRepoProvider
+
+        do {
+            self.generator = try dependeciesGenerator.createGenerator(for: selectedRemoteRepoProvider)
+        } catch {
+            self.fail(message: "Failed create generator: \(error)")
+        }
+
         Log.isDebugLoggingEnabled = debug.value
-
+
+        guard let generator = generator else {
+            self.fail(message: "Failed to setup generator")
+        }
+
         firstly {
             generator.generate(configurationPath: configurationPath, force: force.value)
         }.done { result in
@@ -68,4 +89,5 @@ private extension String {
     // MARK: - Type Properties
 
     static let defaultConfigurationPath = ".analyticsGen.yml"
+    static let defaultRemoteRepoProvider = "forgejo"
 }
diff --git a/Sources/AnalyticsGen/DefaultDependeciesGenerator.swift b/Sources/AnalyticsGen/DefaultDependeciesGenerator.swift
@@ -0,0 +1,67 @@
+import Foundation
+import AnalyticsGenTools
+import DictionaryCoder
+
+final class DefaultDependeciesGenerator: DependenciesGenerator {
+    let httpService: HTTPService
+    let yamlFileProvider: FileProvider
+    let templateContextCoder: TemplateContextCoder
+    let stencilExtensions: [StencilExtension]
+    let templateRenderer: TemplateRenderer
+
+    init() {
+        self.httpService = HTTPService()
+        self.yamlFileProvider = YAMLFileProvider()
+        self.templateContextCoder = DefaultTemplateContextCoder()
+        self.stencilExtensions = [
+            StencilStringUppercasePrefixFilter(),
+            StencilStringUppercaseSuffixFilter(),
+            StencilStringMultilineFilter(),
+            StencilStringMultilineAlignmentFilter()
+        ]
+        self.templateRenderer = DefaultTemplateRenderer(
+            contextCoder: templateContextCoder,
+            stencilExtensions: stencilExtensions
+        )
+    }
+
+    func createGenerator(for provider: String) throws -> EventGenerator {
+        let repoProviderType = RemoteRepoProviderType.from(string: provider)
+
+        var remoteRepoProvider: RemoteRepoProvider?
+
+        switch repoProviderType {
+        case .forgejo:
+            remoteRepoProvider = ForgejoRemoteRepoProvider(httpService: httpService)
+        case .github:
+            remoteRepoProvider = GitHubRemoteRepoProvider(httpService: httpService)
+        case .unknown:
+            throw DependeciesGeneratorError.unknownProvider
+        }
+
+        guard let remoteRepoProvider = remoteRepoProvider else {
+            throw DependeciesGeneratorError.unknownProvider
+        }
+
+        let remoteRepoReferenceFinder = RemoteRepoReferenceFinder(remoteRepoProvider: remoteRepoProvider)
+
+        return DefaultEventGenerator(
+            fileProvider: yamlFileProvider,
+            remoteRepoProvider: remoteRepoProvider,
+            templateRenderer: templateRenderer,
+            dictionaryDecoder: DictionaryDecoder(),
+            remoteRepoReferenceFinder: remoteRepoReferenceFinder
+        )
+    }
+}
+
+enum DependeciesGeneratorError: Error {
+    case unknownProvider
+
+    var errorDescription: String {
+        switch self {
+        case .unknownProvider:
+            "The specified remote repository provider is unknown"
+        }
+    }
+}
diff --git a/Sources/AnalyticsGen/Dependencies.swift b/Sources/AnalyticsGen/Dependencies.swift
diff --git a/Sources/AnalyticsGen/DependenciesGenerator.swift b/Sources/AnalyticsGen/DependenciesGenerator.swift
@@ -0,0 +1,11 @@
+import AnalyticsGenTools
+
+protocol DependenciesGenerator {
+    var httpService: HTTPService { get }
+    var yamlFileProvider: FileProvider { get }
+    var templateContextCoder: TemplateContextCoder { get }
+    var stencilExtensions: [StencilExtension] { get }
+    var templateRenderer: TemplateRenderer { get }
+
+    func createGenerator(for provider: String) throws -> EventGenerator
+}
diff --git a/Sources/AnalyticsGen/Generators/Event/DefaultEventGenerator.swift b/Sources/AnalyticsGen/Generators/Event/DefaultEventGenerator.swift
@@ -267,24 +267,24 @@ final class DefaultEventGenerator: EventGenerator {
     }
 
     private func generateFromRemoteRepo(
-        gitHubConfiguration: GitHubSourceConfiguration,
+        remoteRepoConfiguration: RemoteRepoSourceConfiguration,
         ref: String,
         configuration: GeneratedConfiguration,
         remoteReferenceSHA: String
     ) -> Promise<EventGenerationResult> {
         firstly {
             remoteRepoProvider.fetchRepo(
-                owner: gitHubConfiguration.owner,
-                repo: gitHubConfiguration.repo,
+                owner: remoteRepoConfiguration.owner,
+                repo: remoteRepoConfiguration.repo,
                 ref: ref,
-                token: try gitHubConfiguration.accessToken.resolveToken(),
+                token: try remoteRepoConfiguration.accessToken.resolveToken(),
                 key: configuration.name
             )
         }.map { repoPathURL in
             try self.generate(
                 configuration: configuration,
-                targetPath: gitHubConfiguration.path,
-                schemasPath: gitHubConfiguration.path.map { targetPath in
+                targetPath: remoteRepoConfiguration.path,
+                schemasPath: remoteRepoConfiguration.path.map { targetPath in
                     repoPathURL.appendingPathComponent(targetPath)
                 } ?? repoPathURL
             )
@@ -296,17 +296,17 @@ final class DefaultEventGenerator: EventGenerator {
     }
 
     private func fetchRemoteReferenceSHA(
-        gitHubConfiguration: GitHubSourceConfiguration,
+        remoteRepoConfiguration: RemoteRepoSourceConfiguration,
         gitReferenceType: GitReferenceType
     ) -> Promise<String> {
         switch gitReferenceType {
         case .tag, .branch:
             return firstly {
                 remoteRepoProvider.fetchReference(
-                    owner: gitHubConfiguration.owner,
-                    repo: gitHubConfiguration.repo,
+                    owner: remoteRepoConfiguration.owner,
+                    repo: remoteRepoConfiguration.repo,
                     ref: gitReferenceType.rawValue,
-                    token: try gitHubConfiguration.accessToken.resolveToken()
+                    token: try remoteRepoConfiguration.accessToken.resolveToken()
                 )
             }.map { reference in
                 reference.object.sha
@@ -318,13 +318,13 @@ final class DefaultEventGenerator: EventGenerator {
     }
 
     private func generateFromRemoteRepo(
-        gitHubConfiguration: GitHubSourceConfiguration,
+        remoteRepoConfiguration: RemoteRepoSourceConfiguration,
         gitReferenceType: GitReferenceType,
         configuration: GeneratedConfiguration,
         force: Bool
     ) -> Promise<EventGenerationResult> {
         firstly {
-            fetchRemoteReferenceSHA(gitHubConfiguration: gitHubConfiguration, gitReferenceType: gitReferenceType)
+            fetchRemoteReferenceSHA(remoteRepoConfiguration: remoteRepoConfiguration, gitReferenceType: gitReferenceType)
         }.then { remoteReferenceSHA in
             let shouldPerformGeneration = try self.shouldGenerate(
                 configuration: configuration,
@@ -333,7 +333,7 @@ final class DefaultEventGenerator: EventGenerator {
 
             if shouldPerformGeneration || force {
                 return self.generateFromRemoteRepo(
-                    gitHubConfiguration: gitHubConfiguration,
+                    remoteRepoConfiguration: remoteRepoConfiguration,
                     ref: gitReferenceType.rawValue,
                     configuration: configuration,
                     remoteReferenceSHA: remoteReferenceSHA
@@ -345,8 +345,8 @@ final class DefaultEventGenerator: EventGenerator {
     }
 
     private func performFinders(
-        finderConfigurations: [GitHubReferenceFinderConfiguration],
-        gitHubConfiguration: GitHubSourceConfiguration,
+        finderConfigurations: [RemoteRepoReferenceFinderConfiguration],
+        remoteRepoConfiguration: RemoteRepoSourceConfiguration,
         generatedConfiguration: GeneratedConfiguration,
         force: Bool
     ) throws -> Promise<EventGenerationResult> {
@@ -361,7 +361,7 @@ final class DefaultEventGenerator: EventGenerator {
         return try remoteRepoReferenceFinder
             .findReference(
                 configurations: finderConfigurations,
-                gitHubConfiguration: gitHubConfiguration
+                remoteRepoConfiguration: remoteRepoConfiguration
             )
             .map { gitReferenceType in
                 if let gitReferenceType {
@@ -381,7 +381,7 @@ final class DefaultEventGenerator: EventGenerator {
             }
             .then { gitReferenceType in
                 self.generateFromRemoteRepo(
-                    gitHubConfiguration: gitHubConfiguration,
+                    remoteRepoConfiguration: remoteRepoConfiguration,
                     gitReferenceType: gitReferenceType,
                     configuration: generatedConfiguration,
                     force: force
@@ -402,19 +402,19 @@ final class DefaultEventGenerator: EventGenerator {
 
             return .value(.success)
 
-        case .gitHub(let gitHubConfiguration):
-            switch gitHubConfiguration.ref {
+        case .remoteRepo(let remoteRepoConfiguration):
+            switch remoteRepoConfiguration.ref {
             case .tag(let name):
                 return generateFromRemoteRepo(
-                    gitHubConfiguration: gitHubConfiguration,
+                    remoteRepoConfiguration: remoteRepoConfiguration,
                     gitReferenceType: .tag(name: name),
                     configuration: configuration,
                     force: force
                 )
 
             case .branch(let name):
                 return generateFromRemoteRepo(
-                    gitHubConfiguration: gitHubConfiguration,
+                    remoteRepoConfiguration: remoteRepoConfiguration,
                     gitReferenceType: .branch(name: name),
                     configuration: configuration,
                     force: force
@@ -423,7 +423,7 @@ final class DefaultEventGenerator: EventGenerator {
             case .finders(let finders):
                 return try performFinders(
                     finderConfigurations: finders,
-                    gitHubConfiguration: gitHubConfiguration,
+                    remoteRepoConfiguration: remoteRepoConfiguration,
                     generatedConfiguration: configuration,
                     force: force
                 )

diff --git a/Sources/AnalyticsGen/Generators/Event/Finders/RemoteRepoReferenceFinder.swift b/Sources/AnalyticsGen/Generators/Event/Finders/RemoteRepoReferenceFinder.swift
@@ -30,8 +30,8 @@ final class RemoteRepoReferenceFinder {
     }
 
     private func findReference(
-        configuration: GitHubReferenceFinderConfiguration,
-        gitHubConfiguration: GitHubSourceConfiguration,
+        configuration: RemoteRepoReferenceFinderConfiguration,
+        remoteRepoConfiguration: RemoteRepoSourceConfiguration,
         tags: [String]
     ) throws -> GitReferenceType? {
         guard try configuration.runCondition?.isSatisfyCondition() ?? true else {
@@ -84,34 +84,34 @@ final class RemoteRepoReferenceFinder {
         case .lastCommit(let branch):
             return try remoteRepoProvider
                 .fetchLastCommitSHA(
-                    owner: gitHubConfiguration.owner,
-                    repo: gitHubConfiguration.repo,
+                    owner: remoteRepoConfiguration.owner,
+                    repo: remoteRepoConfiguration.repo,
                     branch: branch,
-                    token: try gitHubConfiguration.accessToken.resolveToken()
+                    token: try remoteRepoConfiguration.accessToken.resolveToken()
                 )
                 .map { .commit(sha: $0) }
                 .wait()
         }
     }
 
     func findReference(
-        configurations: [GitHubReferenceFinderConfiguration],
-        gitHubConfiguration: GitHubSourceConfiguration
+        configurations: [RemoteRepoReferenceFinderConfiguration],
+        remoteRepoConfiguration: RemoteRepoSourceConfiguration
     ) throws -> Promise<GitReferenceType?> {
         remoteRepoProvider
             .fetchTagList(
-                owner: gitHubConfiguration.owner,
-                repo: gitHubConfiguration.repo,
+                owner: remoteRepoConfiguration.owner,
+                repo: remoteRepoConfiguration.repo,
                 count: 100,
-                token: try gitHubConfiguration.accessToken.resolveToken()
+                token: try remoteRepoConfiguration.accessToken.resolveToken()
             )
             .map(on: .global()) { tags in
                 try configurations
                     .enumerated()
                     .mapFirst { index, configuration in
                         let gitRefenceType = try self.findReference(
                             configuration: configuration,
-                            gitHubConfiguration: gitHubConfiguration,
+                            remoteRepoConfiguration: remoteRepoConfiguration,
                             tags: tags
                         )
 

diff --git a/...Finder/FinderConditionConfiguration.swift → ...Finder/FinderConditionConfiguration.swift b/...Finder/FinderConditionConfiguration.swift → ...Finder/FinderConditionConfiguration.swift
diff --git a/...ub/Finder/FinderSourceConfiguration.swift → ...po/Finder/FinderSourceConfiguration.swift b/...ub/Finder/FinderSourceConfiguration.swift → ...po/Finder/FinderSourceConfiguration.swift
diff --git a/.../GitHubReferenceFinderConfiguration.swift → ...oteRepoReferenceFinderConfiguration.swift b/.../GitHubReferenceFinderConfiguration.swift → ...oteRepoReferenceFinderConfiguration.swift
@@ -1,8 +1,8 @@
 import Foundation
 
-struct GitHubReferenceFinderConfiguration: Decodable, Equatable {
+struct RemoteRepoReferenceFinderConfiguration: Decodable, Equatable {
 
-    let type: GitHubReferenceFinderTypeConfiguration
+    let type: RemoteRepoReferenceFinderTypeConfiguration
     let runCondition: FinderSourceConfiguration?
 
     init(from decoder: Decoder) throws {
@@ -38,7 +38,7 @@ struct GitHubReferenceFinderConfiguration: Decodable, Equatable {
     }
 }
 
-extension GitHubReferenceFinderConfiguration {
+extension RemoteRepoReferenceFinderConfiguration {
 
     private enum CodingKeys: String, CodingKey {
         case type