Move revisionInfo to GitClient

Author: finestructure

Sources/App/Commands/Analyze.swift

@@ -407,7 +407,7 @@ extension Analyze {
         let references = [defaultBranch] + tags
         return try await references
             .mapAsync { ref in
-                let revInfo = try await Current.git.revisionInfo(ref, cacheDir)
+                let revInfo = try await git.revisionInfo(ref, at: cacheDir)
                 let url = package.model.versionUrl(for: ref)
                 return try Version(package: package.model,
                                    commit: revInfo.commit,

Sources/App/Core/AppEnvironment.swift

@@ -44,11 +44,9 @@ extension AppEnvironment {
 
 
 struct Git: Sendable {
-    var revisionInfo: @Sendable (Reference, String) async throws -> RevisionInfo
     var shortlog: @Sendable (String) async throws -> String
 
     static let live: Self = .init(
-        revisionInfo: { ref, path in try await revisionInfo(ref, at: path) },
         shortlog: { path in try await shortlog(at: path) }
     )
 }

Sources/App/Core/Dependencies/GitClient.swift

@@ -26,6 +26,7 @@ struct GitClient {
     var getTags: @Sendable (_ at: String) async throws -> [Reference]
     var hasBranch: @Sendable (Reference, _ at: String) async throws -> Bool
     var lastCommitDate: @Sendable (_ at: String) async throws -> Date
+    var revisionInfo: @Sendable (Reference, _ at: String) async throws -> Git.RevisionInfo
 }
 
 
@@ -36,7 +37,8 @@ extension GitClient: DependencyKey {
             firstCommitDate: { path in try await Git.firstCommitDate(at: path) },
             getTags: { path in try await Git.getTags(at: path) },
             hasBranch: { ref, path in try await Git.hasBranch(ref, at: path) },
-            lastCommitDate: { path in try await Git.lastCommitDate(at: path) }
+            lastCommitDate: { path in try await Git.lastCommitDate(at: path) },
+            revisionInfo: { ref, path in try await Git.revisionInfo(ref, at: path) }
         )
     }
 }

Tests/AppTests/AnalyzeErrorTests.swift

@@ -73,11 +73,6 @@ final class AnalyzeErrorTests: AppTestCase {
             Repository(package: pkgs[1], defaultBranch: "main", name: "2", owner: "foo"),
         ].save(on: app.db)
 
-        Current.git.revisionInfo = { @Sendable ref, checkoutDir in
-            if checkoutDir.hasSuffix("foo-1") { return .init(commit: "commit \(ref)", date: .t1) }
-            if checkoutDir.hasSuffix("foo-2") { return .init(commit: "commit \(ref)", date: .t1) }
-            throw SetupError()
-        }
         Current.git.shortlog = { @Sendable _ in
             """
             1000\tPerson 1
@@ -104,6 +99,11 @@ final class AnalyzeErrorTests: AppTestCase {
             }
             $0.git.hasBranch = { @Sendable _, _ in true }
             $0.git.lastCommitDate = { @Sendable _ in .t1 }
+            $0.git.revisionInfo = { @Sendable ref, checkoutDir in
+                if checkoutDir.hasSuffix("foo-1") { return .init(commit: "commit \(ref)", date: .t1) }
+                if checkoutDir.hasSuffix("foo-2") { return .init(commit: "commit \(ref)", date: .t1) }
+                throw SetupError()
+            }
             $0.httpClient.mastodonPost = { @Sendable [socialPosts = self.socialPosts] message in
                 socialPosts.withValue { $0.append(message) }
             }

Tests/AppTests/AnalyzerTests.swift

@@ -227,6 +227,22 @@ class AnalyzerTests: AppTestCase {
             $0.git.getTags = { @Sendable _ in [.tag(1, 0, 0), .tag(1, 1, 1)] }
             $0.git.hasBranch = { @Sendable _, _ in true }
             $0.git.lastCommitDate = { @Sendable _ in .t2 }
+            $0.git.revisionInfo = { @Sendable ref, _ in
+                // simulate the following scenario:
+                //   - main branch has moved from commit0 -> commit3 (timestamp t3)
+                //   - 1.0.0 has been re-tagged (!) from commit0 -> commit1 (timestamp t1)
+                //   - 1.1.1 has been added at commit2 (timestamp t2)
+                switch ref {
+                    case _ where ref == .tag(1, 0, 0):
+                        return .init(commit: "commit1", date: .t1)
+                    case _ where ref == .tag(1, 1, 1):
+                        return .init(commit: "commit2", date: .t2)
+                    case .branch("main"):
+                        return .init(commit: "commit3", date: .t3)
+                    default:
+                        fatalError("unexpected reference: \(ref)")
+                }
+            }
             $0.httpClient.mastodonPost = { @Sendable _ in }
         } operation: {
             // setup
@@ -251,22 +267,6 @@ class AnalyzerTests: AppTestCase {
                               packageName: "foo-1",
                               reference: .tag(1, 0, 0)).save(on: app.db)
 
-            Current.git.revisionInfo = { @Sendable ref, _ in
-                // simulate the following scenario:
-                //   - main branch has moved from commit0 -> commit3 (timestamp t3)
-                //   - 1.0.0 has been re-tagged (!) from commit0 -> commit1 (timestamp t1)
-                //   - 1.1.1 has been added at commit2 (timestamp t2)
-                switch ref {
-                    case _ where ref == .tag(1, 0, 0):
-                        return .init(commit: "commit1", date: .t1)
-                    case _ where ref == .tag(1, 1, 1):
-                        return .init(commit: "commit2", date: .t2)
-                    case .branch("main"):
-                        return .init(commit: "commit3", date: .t3)
-                    default:
-                        fatalError("unexpected reference: \(ref)")
-                }
-            }
             Current.git.shortlog = { @Sendable _ in
             """
             10\tPerson 1
@@ -366,6 +366,7 @@ class AnalyzerTests: AppTestCase {
             $0.git.getTags = { @Sendable _ in [.tag(1, 0, 0)] }
             $0.git.hasBranch = { @Sendable _, _ in true }
             $0.git.lastCommitDate = { @Sendable _ in .t1 }
+            $0.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha", date: .t0) }
         } operation: {
             // setup
             let urls = ["https://github.com/foo/1", "https://github.com/foo/2"]
@@ -375,7 +376,6 @@ class AnalyzerTests: AppTestCase {
             }
             let lastUpdate = Date()
 
-            Current.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha", date: .t0) }
             Current.git.shortlog = { @Sendable _ in
             """
             10\tPerson 1
@@ -565,9 +565,9 @@ class AnalyzerTests: AppTestCase {
         try await withDependencies {
             $0.git.getTags = { @Sendable _ in [.tag(1, 2, 3)] }
             $0.git.hasBranch = { @Sendable _, _ in true }
+            $0.git.revisionInfo = { @Sendable ref, _ in .init(commit: "sha-\(ref)", date: .t0) }
         } operation: {
             // setup
-            Current.git.revisionInfo = { @Sendable ref, _ in .init(commit: "sha-\(ref)", date: .t0) }
             do {
                 let pkg = Package(id: .id0, url: "1".asGithubUrl.url)
                 try await pkg.save(on: app.db)
@@ -628,13 +628,13 @@ class AnalyzerTests: AppTestCase {
         try await withDependencies {
             $0.git.getTags = { @Sendable _ in [.tag(1, 2, 3)] }
             $0.git.hasBranch = { @Sendable _, _ in true }
-        } operation: {
-            //setup
-            Current.git.revisionInfo = { @Sendable ref, _ in
+            $0.git.revisionInfo = { @Sendable ref, _ in
                 if ref == .branch("main") { return . init(commit: "sha.main", date: .t0) }
                 if ref == .tag(1, 2, 3) { return .init(commit: "sha.1.2.3", date: .t1) }
                 fatalError("unknown ref: \(ref)")
             }
+        } operation: {
+            //setup
             Current.shell.run = { @Sendable cmd, _ in throw TestError.unknownCommand }
             let pkgId = UUID()
             do {
@@ -910,9 +910,9 @@ class AnalyzerTests: AppTestCase {
             $0.git.getTags = { @Sendable _ in [.tag(1, 0, 0), .tag(2, 0, 0)] }
             $0.git.hasBranch = { @Sendable _, _ in true }
             $0.git.lastCommitDate = { @Sendable _ in .t1 }
+            $0.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha", date: .t0) }
         } operation: {
             // setup
-            Current.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha", date: .t0) }
             Current.git.shortlog = { @Sendable _ in
             """
             10\tPerson 1
@@ -1344,9 +1344,9 @@ class AnalyzerTests: AppTestCase {
             }
             Current.shell.run = { @Sendable cmd, path in "" }
 
-            do {  // first scenario: bad getTags
-                Current.git.revisionInfo = { @Sendable _, _ in .init(commit: "", date: .t1) }
-
+            try await withDependencies {  // first scenario: bad getTags
+                $0.git.revisionInfo = { @Sendable _, _ in .init(commit: "", date: .t1) }
+            } operation: {
                 // MUT
                 try await Analyze.analyze(client: app.client,
                                           database: app.db,
@@ -1361,9 +1361,8 @@ class AnalyzerTests: AppTestCase {
 
             try await withDependencies {  // second scenario: revisionInfo throws
                 $0.git.getTags = { @Sendable _ in [.tag(1, 0, 0)] }
+                $0.git.revisionInfo = { @Sendable _, _ in throw TestError.unspecifiedError }
             } operation: {
-                Current.git.revisionInfo = { @Sendable _, _ in throw TestError.unspecifiedError }
-
                 // MUT
                 try await Analyze.analyze(client: app.client,
                                           database: app.db,
@@ -1378,9 +1377,8 @@ class AnalyzerTests: AppTestCase {
 
             try await withDependencies {  // second scenario: gitTags throws
                 $0.git.getTags = { @Sendable _ in throw TestError.unspecifiedError }
+                $0.git.revisionInfo = { @Sendable _, _ in .init(commit: "", date: .t1) }
             } operation: {
-                Current.git.revisionInfo = { @Sendable _, _ in .init(commit: "", date: .t1) }
-
                 // MUT
                 try await Analyze.analyze(client: app.client,
                                           database: app.db,
@@ -1395,8 +1393,8 @@ class AnalyzerTests: AppTestCase {
 
             try await withDependencies {  // third scenario: everything throws
                 $0.git.getTags = { @Sendable _ in throw TestError.unspecifiedError }
+                $0.git.revisionInfo = { @Sendable _, _ in throw TestError.unspecifiedError }
             } operation: {
-                Current.git.revisionInfo = { @Sendable _, _ in throw TestError.unspecifiedError }
                 Current.shell.run = { @Sendable _, _ in throw TestError.unspecifiedError }
 
                 // MUT
@@ -1453,8 +1451,8 @@ class AnalyzerTests: AppTestCase {
             }
             Current.shell.run = { @Sendable cmd, path in return "" }
 
-            do {  // ensure happy path passes test (no revision changes)
-                Current.git.revisionInfo = { @Sendable ref, _ in
+            try await withDependencies {  // ensure happy path passes test (no revision changes)
+                $0.git.revisionInfo = { @Sendable ref, _ in
                     switch ref {
                         case .tag(.init(1, 0, 0), "1.0.0"):
                             return .init(commit: "commit0", date: .t0)
@@ -1464,7 +1462,7 @@ class AnalyzerTests: AppTestCase {
                             throw Error()
                     }
                 }
-
+            } operation: {
                 // MUT
                 try await Analyze.analyze(client: app.client,
                                           database: app.db,
@@ -1482,8 +1480,8 @@ class AnalyzerTests: AppTestCase {
             pkg.processingStage = .ingestion
             try await pkg.save(on: app.db)
 
-            do {  // simulate "main" branch moving forward to ("commit0", .t1)
-                Current.git.revisionInfo = { @Sendable ref, _ in
+            try await withDependencies {  // simulate "main" branch moving forward to ("commit0", .t1)
+                $0.git.revisionInfo = { @Sendable ref, _ in
                     switch ref {
                         case .tag(.init(1, 0, 0), "1.0.0"):
                             return .init(commit: "commit0", date: .t0)
@@ -1494,6 +1492,7 @@ class AnalyzerTests: AppTestCase {
                             throw Error()
                     }
                 }
+            } operation: {
                 Current.shell.run = { @Sendable cmd, path in
                     // simulate error in getPackageInfo by failing checkout
                     if cmd == .gitCheckout(branch: "main") {
@@ -1535,6 +1534,7 @@ class AnalyzerTests: AppTestCase {
             $0.git.getTags = { @Sendable _ in [] }
             $0.git.hasBranch = { @Sendable _, _ in true }
             $0.git.lastCommitDate = { @Sendable _ in .t1 }
+            $0.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha1", date: .t0) }
         } operation: {
             // setup
             let pkg = try await savePackage(on: app.db, id: .id0, "https://github.com/foo/1".url, processingStage: .ingestion)
@@ -1543,7 +1543,6 @@ class AnalyzerTests: AppTestCase {
                                  name: "1",
                                  owner: "foo",
                                  stars: 100).save(on: app.db)
-            Current.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha1", date: .t0) }
             Current.git.shortlog = { @Sendable _ in "10\tPerson 1" }
             Current.shell.run = { @Sendable cmd, path in
                 if cmd == .swiftDumpPackage { return .packageDump(name: "foo1") }
@@ -1576,15 +1575,16 @@ class AnalyzerTests: AppTestCase {
                 XCTAssertEqual(pkg?.scoreDetails?.numberOfDependencies, 1)
             }
 
-            // now we simulate a new version on the default branch
-            Current.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha2", date: .t1) }
-            
-            // third analysis pass
-            try await Analyze.analyze(client: app.client, database: app.db, mode: .id(.id0))
-            do { // validate
-                let pkg = try await Package.query(on: app.db).first()
-                // numberOfDependencies must be preserved as 1, even though we've not built this version yet
-                XCTAssertEqual(pkg?.scoreDetails?.numberOfDependencies, 1)
+            try await withDependencies {  // now we simulate a new version on the default branch
+                $0.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha2", date: .t1) }
+            } operation: {
+                // third analysis pass
+                try await Analyze.analyze(client: app.client, database: app.db, mode: .id(.id0))
+                do { // validate
+                    let pkg = try await Package.query(on: app.db).first()
+                    // numberOfDependencies must be preserved as 1, even though we've not built this version yet
+                    XCTAssertEqual(pkg?.scoreDetails?.numberOfDependencies, 1)
+                }
             }
         }
 }

Tests/AppTests/AnalyzerVersionThrottlingTests.swift

@@ -201,11 +201,11 @@ class AnalyzerVersionThrottlingTests: AppTestCase {
             try await old.save(on: app.db)
             let jpr = try await Package.fetchCandidate(app.db, id: pkg.id!)
 
-            do {  // keep old version if too soon
-                Current.git.revisionInfo = { @Sendable _, _ in
+            try await withDependencies {  // keep old version if too soon
+                $0.git.revisionInfo = { @Sendable _, _ in
                         .init(commit: "sha_new", date: .t0.addingTimeInterval(.hours(-1)) )
                 }
-
+            } operation: {
                 // MUT
                 let res = try await Analyze.diffVersions(client: app.client,
                                                          transaction: app.db,
@@ -219,13 +219,12 @@ class AnalyzerVersionThrottlingTests: AppTestCase {
 
             try await withDependencies {
                 $0.date.now = .t0.addingTimeInterval(.hours(2))
-            } operation: {
                 // new version must come through
-                Current.git.revisionInfo = { @Sendable _, _ in
+                $0.git.revisionInfo = { @Sendable _, _ in
                     // now simulate a newer branch revision
                         .init(commit: "sha_new2", date: .t0.addingTimeInterval(.hours(2)) )
                 }
-
+            } operation: {
                 // MUT
                 let res = try await Analyze.diffVersions(client: app.client,
                                                          transaction: app.db,
@@ -279,10 +278,9 @@ class AnalyzerVersionThrottlingTests: AppTestCase {
 
             try await withDependencies {
                 $0.date.now = commitDates[0]
-            } operation: {
                 // start with a branch revision
-                Current.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha0", date: commitDates[0] ) }
-
+                $0.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha0", date: commitDates[0] ) }
+            } operation: {
                 let delta = try await runVersionReconciliation()
                 XCTAssertEqual(delta.toAdd.map(\.commit), ["sha0"])
                 XCTAssertEqual(delta.toDelete, [])
@@ -291,10 +289,9 @@ class AnalyzerVersionThrottlingTests: AppTestCase {
 
             try await withDependencies {
                 $0.date.now = commitDates[1]
-            } operation: {
                 // one hour later a new commit landed - which should be ignored
-                Current.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha1", date: commitDates[1] ) }
-
+                $0.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha1", date: commitDates[1] ) }
+            } operation: {
                 let delta = try await runVersionReconciliation()
                 XCTAssertEqual(delta.toAdd, [])
                 XCTAssertEqual(delta.toDelete, [])
@@ -305,9 +302,8 @@ class AnalyzerVersionThrottlingTests: AppTestCase {
             for idx in 2...6 {
                 try await withDependencies {
                     $0.date.now = commitDates[idx]
+                    $0.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha\(idx)", date: commitDates[idx] ) }
                 } operation: {
-                    Current.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha\(idx)", date: commitDates[idx] ) }
-
                     let delta = try await runVersionReconciliation()
                     XCTAssertEqual(delta.toAdd, [])
                     XCTAssertEqual(delta.toDelete, [])
@@ -317,10 +313,9 @@ class AnalyzerVersionThrottlingTests: AppTestCase {
 
             try await withDependencies {
                 $0.date.now = commitDates[7]
-            } operation: {
                 // advancing another 4 hours for a total of 25 hours should finally create a new version
-                Current.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha7", date: commitDates[7] ) }
-
+                $0.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha7", date: commitDates[7] ) }
+            } operation: {
                 let delta = try await runVersionReconciliation()
                 XCTAssertEqual(delta.toAdd.map(\.commit), ["sha7"])
                 XCTAssertEqual(delta.toDelete.map(\.commit), ["sha0"])

Tests/AppTests/IngestionTests.swift

@@ -438,8 +438,8 @@ class IngestionTests: AppTestCase {
             $0.git.getTags = { @Sendable _ in [] }
             $0.git.hasBranch = { @Sendable _, _ in true }
             $0.git.lastCommitDate = { @Sendable _ in .t0 }
+            $0.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha0", date: .t0) }
         } operation: { [db = app.db] in
-            Current.git.revisionInfo = { @Sendable _, _ in .init(commit: "sha0", date: .t0) }
             Current.git.shortlog = { @Sendable _ in "" }
             Current.shell.run = { @Sendable cmd, _ in
                 if cmd.description.hasSuffix("package dump-package") {