feat: Integrates configuration-client.

Sources/CliClient/CliClient.swift

@@ -33,66 +33,29 @@ public struct CliClient: Sendable {
     case major, minor, patch, preRelease
   }
 
-  public enum PreReleaseStrategy: Equatable, Sendable {
-    /// Use output of tag, with branch and commit sha.
-    case branchAndCommit
-
-    /// Provide a custom pre-release tag.
-    indirect case custom(String, PreReleaseStrategy? = nil)
-
-    /// Use the output of `git describe --tags`
-    case tag
-  }
-
-  public enum VersionStrategy: Equatable, Sendable {
-    case branchAndCommit
-    case semVar(SemVarOptions)
-
-    // public typealias SemVarOptions = Configuration.SemVar
-
-    public struct SemVarOptions: Equatable, Sendable {
-      let preReleaseStrategy: PreReleaseStrategy?
-      let requireExistingFile: Bool
-      let requireExistingSemVar: Bool
-
-      public init(
-        preReleaseStrategy: PreReleaseStrategy? = nil,
-        requireExistingFile: Bool = true,
-        requireExistingSemVar: Bool = true
-      ) {
-        self.preReleaseStrategy = preReleaseStrategy
-        self.requireExistingFile = requireExistingFile
-        self.requireExistingSemVar = requireExistingSemVar
-      }
-    }
-  }
-
   public struct SharedOptions: Equatable, Sendable {
 
     let dryRun: Bool
     let gitDirectory: String?
     let logLevel: Logger.Level
-    let preReleaseStrategy: PreReleaseStrategy?
-    let target: String
-    let versionStrategy: VersionStrategy
+    let configuration: Configuration
 
     public init(
       dryRun: Bool = false,
       gitDirectory: String? = nil,
       logLevel: Logger.Level = .debug,
-      preReleaseStrategy: PreReleaseStrategy? = nil,
-      target: String,
-      versionStrategy: VersionStrategy = .semVar(.init())
+      configuration: Configuration
     ) {
       self.dryRun = dryRun
-      self.target = target
       self.gitDirectory = gitDirectory
       self.logLevel = logLevel
-      self.preReleaseStrategy = preReleaseStrategy
-      self.versionStrategy = versionStrategy
+      self.configuration = configuration
     }
 
-    var allowPreReleaseTag: Bool { preReleaseStrategy != nil }
+    var allowPreReleaseTag: Bool {
+      guard let semvar = configuration.strategy?.semvar else { return false }
+      return semvar.preRelease != nil
+    }
   }
 
 }

Sources/CliClient/Internal/ConfigurationExtensions.swift

@@ -3,8 +3,29 @@ import Dependencies
 import Foundation
 import GitClient
 
+extension Configuration {
+  func targetUrl(gitDirectory: String?) throws -> URL {
+    guard let target else {
+      throw ConfigurationParsingError.targetNotFound
+    }
+    return try target.url(gitDirectory: gitDirectory)
+  }
+
+  func currentVersion(targetUrl: URL, gitDirectory: String?) async throws -> CurrentVersionContainer {
+    guard let strategy else {
+      throw ConfigurationParsingError.versionNotFound
+    }
+    return try await strategy.currentVersion(
+      targetUrl: targetUrl,
+      gitDirectory: gitDirectory
+    )
+  }
+}
+
 extension Configuration.Target {
   func url(gitDirectory: String?) throws -> URL {
+    @Dependency(\.logger) var logger
+
     let filePath: String
 
     if let path {
@@ -15,13 +36,17 @@ extension Configuration.Target {
       }
 
       var path = module.name
-      if !path.hasPrefix("Sources") || !path.hasPrefix("./Sources") {
-        path = "Sources/\(path)"
-      }
+      logger.debug("module.name: \(path)")
 
       if path.hasPrefix("./") {
         path = String(path.dropFirst(2))
       }
+
+      if !path.hasPrefix("Sources") {
+        logger.debug("no prefix")
+        path = "Sources/\(path)"
+      }
+
       filePath = "\(path)/\(module.fileName)"
     }
 
@@ -70,46 +95,66 @@ extension Configuration.PreReleaseStrategy {
 public extension Configuration.SemVar {
 
   private func applyingPreRelease(_ semVar: SemVar, _ gitDirectory: String?) async throws -> SemVar {
-    guard let preReleaseStrategy = self.preRelease else { return semVar }
+    @Dependency(\.logger) var logger
+    logger.trace("Start apply pre-release to: \(semVar)")
+    guard let preReleaseStrategy = self.preRelease else {
+      logger.trace("No pre-release strategy, returning original semvar.")
+      return semVar
+    }
+
     let preRelease = try await preReleaseStrategy.preReleaseString(gitDirectory: gitDirectory)
+    logger.trace("Pre-release string: \(preRelease)")
+
     return semVar.applyingPreRelease(preRelease)
   }
 
   func currentVersion(file: URL, gitDirectory: String? = nil) async throws -> CurrentVersionContainer.Version {
     @Dependency(\.fileClient) var fileClient
     @Dependency(\.gitClient) var gitClient
+    @Dependency(\.logger) var logger
 
     let fileOutput = try? await fileClient.semVar(file: file, gitDirectory: gitDirectory)
     var semVar = fileOutput?.semVar
+
+    logger.trace("file output semvar: \(String(describing: semVar))")
+
     let usesOptionalType = fileOutput?.usesOptionalType
 
-    if requireExistingFile {
-      guard let semVar else {
-        throw CliClientError.fileDoesNotExist(path: file.cleanFilePath)
-      }
+    // We parsed a semvar from the existing file, use it.
+    if semVar != nil {
       return try await .semVar(
-        applyingPreRelease(semVar, gitDirectory),
+        applyingPreRelease(semVar!, gitDirectory),
         usesOptionalType: usesOptionalType ?? false
       )
     }
 
-    // Didn't have existing semVar loaded from file, so check for git-tag.
+    if requireExistingFile {
+      logger.debug("Failed to parse existing file, and caller requires it.")
+      throw CliClientError.fileDoesNotExist(path: file.cleanFilePath)
+    }
 
+    logger.trace("Does not require existing file, checking git-tag.")
+
+    // Didn't have existing semVar loaded from file, so check for git-tag.
     semVar = try await gitClient.version(.init(
       gitDirectory: gitDirectory,
       style: .tag(exactMatch: false)
     )).semVar
 
-    if requireExistingSemVar {
-      guard let semVar else {
-        fatalError()
-      }
+    if semVar != nil {
       return try await .semVar(
-        applyingPreRelease(semVar, gitDirectory),
+        applyingPreRelease(semVar!, gitDirectory),
         usesOptionalType: usesOptionalType ?? false
       )
     }
 
+    if requireExistingSemVar {
+      logger.trace("Caller requires existing semvar and it was not found in file or git-tag.")
+      throw CliClientError.semVarNotFound
+    }
+
+    // Semvar doesn't exist, so create a new one.
+    logger.trace("Generating new semvar.")
     return try await .semVar(
       applyingPreRelease(.init(), gitDirectory),
       usesOptionalType: usesOptionalType ?? false
@@ -143,6 +188,8 @@ extension Configuration.VersionStrategy {
 }
 
 enum ConfigurationParsingError: Error {
+  case targetNotFound
   case pathOrModuleNotSet
   case versionStrategyError(message: String)
+  case versionNotFound
 }

Sources/CliClient/Internal/FileClient+semVar.swift

@@ -34,6 +34,7 @@ public extension FileClient {
     guard let versionString else {
       throw CliClientError.failedToParseVersionFile
     }
+    logger.debug("Parsed version string: \(versionString)")
     return (String(versionString), isOptional)
   }
 
@@ -41,8 +42,12 @@ public extension FileClient {
     file: URL,
     gitDirectory: String?
   ) async throws -> (semVar: SemVar?, usesOptionalType: Bool) {
+    @Dependency(\.logger) var logger
     let (string, usesOptionalType) = try await getVersionString(fileUrl: file, gitDirectory: gitDirectory)
-    return (SemVar(string: string), usesOptionalType)
+    let semvar = SemVar(string: string)
+    logger.debug("Semvar: \(String(describing: semvar))")
+
+    return (semvar, usesOptionalType)
   }
 
 }

Sources/CliClient/Internal/Internal.swift

@@ -6,30 +6,6 @@ import GitClient
 @_spi(Internal)
 public extension CliClient.SharedOptions {
 
-  func parseTargetUrl() async throws -> URL {
-    @Dependency(\.fileClient) var fileClient
-
-    let target = target.hasPrefix(".") ? String(target.dropFirst()) : target
-    let targetHasSources = target.hasPrefix("Sources") || target.hasPrefix("/Sources")
-
-    var url = url(for: gitDirectory ?? (targetHasSources ? target : "Sources"))
-
-    if gitDirectory != nil {
-      if !targetHasSources {
-        url.appendPathComponent("Sources")
-      }
-      url.appendPathComponent(target)
-    }
-
-    let isDirectory = try await fileClient.isDirectory(url.cleanFilePath)
-
-    if isDirectory {
-      url.appendPathComponent(Constants.defaultFileName)
-    }
-
-    return url
-  }
-
   @discardableResult
   func run(
     _ operation: (CurrentVersionContainer) async throws -> Void
@@ -39,12 +15,12 @@ public extension CliClient.SharedOptions {
     } operation: {
       @Dependency(\.logger) var logger
 
-      let targetUrl = try await parseTargetUrl()
+      let targetUrl = try configuration.targetUrl(gitDirectory: gitDirectory)
       logger.debug("Target: \(targetUrl.cleanFilePath)")
 
       try await operation(
-        versionStrategy.currentVersion(
-          file: targetUrl,
+        configuration.currentVersion(
+          targetUrl: targetUrl,
           gitDirectory: gitDirectory
         )
       )
@@ -124,9 +100,11 @@ extension CliClient.SharedOptions {
 
       switch container.version {
       case .string: // When we did not parse a semVar, just write whatever we parsed for the current version.
+        logger.debug("Failed to parse semvar, but got current version string.")
         try await write(container)
 
       case let .semVar(semVar, usesOptionalType: usesOptionalType):
+        logger.debug("Semvar prior to bumping: \(semVar)")
         let bumped = semVar.bump(type, preRelease: nil) // preRelease is already set on semVar.
         let version = bumped.versionString(withPreReleaseTag: allowPreReleaseTag)
         logger.debug("Bumped version: \(version)")

Sources/CliClient/Internal/SemVar.swift

@@ -37,16 +37,30 @@ public struct SemVar: CustomStringConvertible, Equatable, Sendable {
   }
 
   public init?(string: String) {
+    @Dependency(\.logger) var logger
+
+    logger.trace("Parsing semvar from: \(string)")
+
     let parts = string.split(separator: ".")
+    logger.trace("parts: \(parts)")
     guard parts.count >= 3 else {
       return nil
     }
-    let major = Int(String(parts[0].replacingOccurrences(of: "\"", with: "")))
-    let minor = Int(String(parts[1]))
 
-    let patchParts = parts[2].split(separator: "-")
+    let major = Int(String(parts[0].replacingOccurrences(of: "\"", with: "")))
+    logger.trace("major: \(String(describing: major))")
+
+    let minor = Int(String(parts[1]))
+    logger.trace("minor: \(String(describing: minor))")
+
+    let patchParts = parts[2].replacingOccurrences(of: "\"", with: "").split(separator: "-")
+    logger.trace("patchParts: \(String(describing: patchParts))")
+
     let patch = Int(patchParts.first ?? "0")
+    logger.trace("patch: \(String(describing: patch))")
+
     let preRelease = String(patchParts.dropFirst().joined(separator: "-"))
+    logger.trace("preRelease: \(String(describing: preRelease))")
 
     self.init(
       major: major ?? 0,

Sources/CliClient/Internal/VersionStrategy+currentVersion.swift

@@ -1,104 +1,104 @@
-import ConfigurationClient
-import Dependencies
-import FileClient
-import struct Foundation.URL
-import GitClient
-
-@_spi(Internal)
-public extension CliClient.PreReleaseStrategy {
-
-  func preReleaseString(gitDirectory: String?) async throws -> String {
-    @Dependency(\.gitClient) var gitClient
-    switch self {
-    case let .custom(string, child):
-      guard let child else { return string }
-      return try await "\(string)-\(child.preReleaseString(gitDirectory: gitDirectory))"
-    case .tag:
-      return try await gitClient.version(.init(
-        gitDirectory: gitDirectory,
-        style: .tag(exactMatch: false)
-      )).description
-    case .branchAndCommit:
-      return try await gitClient.version(.init(
-        gitDirectory: gitDirectory,
-        style: .branch(commitSha: true)
-      )).description
-    }
-  }
-}
-
-@_spi(Internal)
-public extension CliClient.VersionStrategy.SemVarOptions {
-
-  private func applyingPreRelease(_ semVar: SemVar, _ gitDirectory: String?) async throws -> SemVar {
-    guard let preReleaseStrategy else { return semVar }
-    let preRelease = try await preReleaseStrategy.preReleaseString(gitDirectory: gitDirectory)
-    return semVar.applyingPreRelease(preRelease)
-  }
-
-  func currentVersion(file: URL, gitDirectory: String? = nil) async throws -> CurrentVersionContainer.Version {
-    @Dependency(\.fileClient) var fileClient
-    @Dependency(\.gitClient) var gitClient
-
-    let fileOutput = try? await fileClient.semVar(file: file, gitDirectory: gitDirectory)
-    var semVar = fileOutput?.semVar
-    let usesOptionalType = fileOutput?.usesOptionalType
-
-    if requireExistingFile {
-      guard let semVar else {
-        throw CliClientError.fileDoesNotExist(path: file.cleanFilePath)
-      }
-      return try await .semVar(
-        applyingPreRelease(semVar, gitDirectory),
-        usesOptionalType: usesOptionalType ?? false
-      )
-    }
-
-    // Didn't have existing semVar loaded from file, so check for git-tag.
-
-    semVar = try await gitClient.version(.init(
-      gitDirectory: gitDirectory,
-      style: .tag(exactMatch: false)
-    )).semVar
-    if requireExistingSemVar {
-      guard let semVar else {
-        fatalError()
-      }
-      return try await .semVar(
-        applyingPreRelease(semVar, gitDirectory),
-        usesOptionalType: usesOptionalType ?? false
-      )
-    }
-
-    return try await .semVar(
-      applyingPreRelease(.init(), gitDirectory),
-      usesOptionalType: usesOptionalType ?? false
-    )
-  }
-}
-
-@_spi(Internal)
-public extension CliClient.VersionStrategy {
-
-  func currentVersion(file: URL, gitDirectory: String?) async throws -> CurrentVersionContainer {
-    @Dependency(\.gitClient) var gitClient
-
-    switch self {
-    case .branchAndCommit:
-      return try await .init(
-        targetUrl: file,
-        version: .string(
-          gitClient.version(.init(
-            gitDirectory: gitDirectory,
-            style: .branch(commitSha: true)
-          )).description
-        )
-      )
-    case let .semVar(options):
-      return try await .init(
-        targetUrl: file,
-        version: options.currentVersion(file: file, gitDirectory: gitDirectory)
-      )
-    }
-  }
-}
+// import ConfigurationClient
+// import Dependencies
+// import FileClient
+// import struct Foundation.URL
+// import GitClient
+//
+// @_spi(Internal)
+// public extension CliClient.PreReleaseStrategy {
+//
+//   func preReleaseString(gitDirectory: String?) async throws -> String {
+//     @Dependency(\.gitClient) var gitClient
+//     switch self {
+//     case let .custom(string, child):
+//       guard let child else { return string }
+//       return try await "\(string)-\(child.preReleaseString(gitDirectory: gitDirectory))"
+//     case .tag:
+//       return try await gitClient.version(.init(
+//         gitDirectory: gitDirectory,
+//         style: .tag(exactMatch: false)
+//       )).description
+//     case .branchAndCommit:
+//       return try await gitClient.version(.init(
+//         gitDirectory: gitDirectory,
+//         style: .branch(commitSha: true)
+//       )).description
+//     }
+//   }
+// }
+//
+// @_spi(Internal)
+// public extension CliClient.VersionStrategy.SemVarOptions {
+//
+//   private func applyingPreRelease(_ semVar: SemVar, _ gitDirectory: String?) async throws -> SemVar {
+//     guard let preReleaseStrategy else { return semVar }
+//     let preRelease = try await preReleaseStrategy.preReleaseString(gitDirectory: gitDirectory)
+//     return semVar.applyingPreRelease(preRelease)
+//   }
+//
+//   func currentVersion(file: URL, gitDirectory: String? = nil) async throws -> CurrentVersionContainer.Version {
+//     @Dependency(\.fileClient) var fileClient
+//     @Dependency(\.gitClient) var gitClient
+//
+//     let fileOutput = try? await fileClient.semVar(file: file, gitDirectory: gitDirectory)
+//     var semVar = fileOutput?.semVar
+//     let usesOptionalType = fileOutput?.usesOptionalType
+//
+//     if requireExistingFile {
+//       guard let semVar else {
+//         throw CliClientError.fileDoesNotExist(path: file.cleanFilePath)
+//       }
+//       return try await .semVar(
+//         applyingPreRelease(semVar, gitDirectory),
+//         usesOptionalType: usesOptionalType ?? false
+//       )
+//     }
+//
+//     // Didn't have existing semVar loaded from file, so check for git-tag.
+//
+//     semVar = try await gitClient.version(.init(
+//       gitDirectory: gitDirectory,
+//       style: .tag(exactMatch: false)
+//     )).semVar
+//     if requireExistingSemVar {
+//       guard let semVar else {
+//         fatalError()
+//       }
+//       return try await .semVar(
+//         applyingPreRelease(semVar, gitDirectory),
+//         usesOptionalType: usesOptionalType ?? false
+//       )
+//     }
+//
+//     return try await .semVar(
+//       applyingPreRelease(.init(), gitDirectory),
+//       usesOptionalType: usesOptionalType ?? false
+//     )
+//   }
+// }
+//
+// @_spi(Internal)
+// public extension CliClient.VersionStrategy {
+//
+//   func currentVersion(file: URL, gitDirectory: String?) async throws -> CurrentVersionContainer {
+//     @Dependency(\.gitClient) var gitClient
+//
+//     switch self {
+//     case .branchAndCommit:
+//       return try await .init(
+//         targetUrl: file,
+//         version: .string(
+//           gitClient.version(.init(
+//             gitDirectory: gitDirectory,
+//             style: .branch(commitSha: true)
+//           )).description
+//         )
+//       )
+//     case let .semVar(options):
+//       return try await .init(
+//         targetUrl: file,
+//         version: options.currentVersion(file: file, gitDirectory: gitDirectory)
+//       )
+//     }
+//   }
+// }