Model a small subset of the git command

Author: cmcgee1024

Sources/SwiftlyCore/Commands.swift

@@ -279,3 +279,207 @@ extension SystemCommand.GetentCommand: Output {
         return entries
     }
 }
+
+extension SystemCommand {
+    public static func git(executable: Executable = GitCommand.defaultExecutable, workingDir: FilePath? = nil) -> GitCommand {
+        GitCommand(executable: executable, workingDir: workingDir)
+    }
+
+    public struct GitCommand {
+        public static var defaultExecutable: Executable { .name("git") }
+
+        var executable: Executable
+
+        var workingDir: FilePath?
+
+        internal init(executable: Executable, workingDir: FilePath?) {
+            self.executable = executable
+            self.workingDir = workingDir
+        }
+
+        func config() -> Configuration {
+            var args: [String] = []
+
+            if let workingDir {
+                args += ["-C", "\(workingDir)"]
+            }
+
+            return Configuration(
+                executable: self.executable,
+                arguments: Arguments(args),
+                environment: .inherit
+            )
+        }
+
+        public func _init() -> InitCommand {
+            InitCommand(self)
+        }
+
+        public struct InitCommand {
+            var git: GitCommand
+
+            internal init(_ git: GitCommand) {
+                self.git = git
+            }
+
+            public func config() -> Configuration {
+                var c = self.git.config()
+
+                var args = c.arguments.storage.map(\.description)
+
+                args += ["init"]
+
+                c.arguments = .init(args)
+
+                return c
+            }
+        }
+
+        public func commit(_ options: CommitCommand.Option...) -> CommitCommand {
+            self.commit(options: options)
+        }
+
+        public func commit(options: [CommitCommand.Option]) -> CommitCommand {
+            CommitCommand(self, options: options)
+        }
+
+        public struct CommitCommand {
+            var git: GitCommand
+
+            var options: [Option]
+
+            internal init(_ git: GitCommand, options: [Option]) {
+                self.git = git
+                self.options = options
+            }
+
+            public enum Option {
+                case allowEmpty
+                case allowEmptyMessage
+                case message(String)
+
+                public func args() -> [String] {
+                    switch self {
+                    case .allowEmpty:
+                        ["--allow-empty"]
+                    case .allowEmptyMessage:
+                        ["--allow-empty-message"]
+                    case let .message(message):
+                        ["-m", message]
+                    }
+                }
+            }
+
+            public func config() -> Configuration {
+                var c = self.git.config()
+
+                var args = c.arguments.storage.map(\.description)
+
+                args += ["commit"]
+                for option in self.options {
+                    args += option.args()
+                }
+
+                c.arguments = .init(args)
+
+                return c
+            }
+        }
+
+        public func log(_ options: LogCommand.Option...) -> LogCommand {
+            LogCommand(self, options)
+        }
+
+        public struct LogCommand {
+            var git: GitCommand
+            var options: [Option]
+
+            internal init(_ git: GitCommand, _ options: [Option]) {
+                self.git = git
+                self.options = options
+            }
+
+            public enum Option {
+                case maxCount(Int)
+                case pretty(String)
+
+                func args() -> [String] {
+                    switch self {
+                    case let .maxCount(num):
+                        return ["--max-count=\(num)"]
+                    case let .pretty(format):
+                        return ["--pretty=\(format)"]
+                    }
+                }
+            }
+
+            public func config() -> Configuration {
+                var c = self.git.config()
+
+                var args = c.arguments.storage.map(\.description)
+
+                args += ["log"]
+
+                for opt in self.options {
+                    args += opt.args()
+                }
+
+                c.arguments = .init(args)
+
+                return c
+            }
+        }
+
+        public func diffIndex(_ options: DiffIndexCommand.Option..., treeIsh: String?) -> DiffIndexCommand {
+            DiffIndexCommand(self, options, treeIsh: treeIsh)
+        }
+
+        public struct DiffIndexCommand {
+            var git: GitCommand
+            var options: [Option]
+            var treeIsh: String?
+
+            internal init(_ git: GitCommand, _ options: [Option], treeIsh: String?) {
+                self.git = git
+                self.options = options
+                self.treeIsh = treeIsh
+            }
+
+            public enum Option {
+                case quiet
+
+                func args() -> [String] {
+                    switch self {
+                    case .quiet:
+                        return ["--quiet"]
+                    }
+                }
+            }
+
+            public func config() -> Configuration {
+                var c = self.git.config()
+
+                var args = c.arguments.storage.map(\.description)
+
+                args += ["diff-index"]
+
+                for opt in self.options {
+                    args += opt.args()
+                }
+
+                if let treeIsh = self.treeIsh {
+                    args += [treeIsh]
+                }
+
+                c.arguments = .init(args)
+
+                return c
+            }
+        }
+    }
+}
+
+extension SystemCommand.GitCommand.LogCommand: Output {}
+extension SystemCommand.GitCommand.DiffIndexCommand: Runnable {}
+extension SystemCommand.GitCommand.InitCommand: Runnable {}
+extension SystemCommand.GitCommand.CommitCommand: Runnable {}

Tests/SwiftlyTests/CommandLineTests.swift

@@ -61,4 +61,54 @@ public struct CommandLineTests {
         config = sys.getent(database: "foo", keys: "abc", "def").config()
         #expect(String(describing: config) == "getent foo abc def")
     }
+
+    @Test func testGitModel() {
+        var config = sys.git().log(.maxCount(1), .pretty("format:%d")).config()
+        #expect(String(describing: config) == "git log --max-count=1 --pretty=format:%d")
+
+        config = sys.git().log().config()
+        #expect(String(describing: config) == "git log")
+
+        config = sys.git().log(.pretty("foo")).config()
+        #expect(String(describing: config) == "git log --pretty=foo")
+
+        config = sys.git().diffIndex(.quiet, treeIsh: "HEAD").config()
+        #expect(String(describing: config) == "git diff-index --quiet HEAD")
+
+        config = sys.git().diffIndex(treeIsh: "main").config()
+        #expect(String(describing: config) == "git diff-index main")
+    }
+
+    @Test(
+        .tags(.medium),
+        .enabled {
+            try await sys.GitCommand.defaultExecutable.exists()
+        }
+    )
+    func testGit() async throws {
+        // GIVEN a simple git repository
+        let tmp = fs.mktemp()
+        try await fs.mkdir(atPath: tmp)
+        try await sys.git(workingDir: tmp)._init().run(Swiftly.currentPlatform)
+
+        // AND a simple history
+        try "Some text".write(to: tmp / "foo.txt", atomically: true)
+        try await Swiftly.currentPlatform.runProgram("git", "-C", "\(tmp)", "add", "foo.txt")
+        try await Swiftly.currentPlatform.runProgram("git", "-C", "\(tmp)", "config", "user.email", "[email protected]")
+        try await sys.git(workingDir: tmp).commit(.message("Initial commit")).run(Swiftly.currentPlatform)
+        try await sys.git(workingDir: tmp).diffIndex(.quiet, treeIsh: "HEAD").run(Swiftly.currentPlatform)
+
+        // WHEN inspecting the log
+        let log = try await sys.git(workingDir: tmp).log(.maxCount(1)).output(Swiftly.currentPlatform)!
+        // THEN it is not empty
+        #expect(log != "")
+
+        // WHEN there is a change to the work tree
+        try "Some new text".write(to: tmp / "foo.txt", atomically: true)
+
+        // THEN diff index finds a change
+        try await #expect(throws: Error.self) {
+            try await sys.git(workingDir: tmp).diffIndex(.quiet, treeIsh: "HEAD").run(Swiftly.currentPlatform)
+        }
+    }
 }

Tools/build-swiftly-release/BuildSwiftlyRelease.swift

@@ -236,17 +236,17 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
         return swift
     }
 
-    func checkGitRepoStatus(_ git: String) async throws {
+    func checkGitRepoStatus(_: String) async throws {
         guard !self.skip else {
             return
         }
 
-        guard let gitTags = try await runProgramOutput(git, "log", "-n1", "--pretty=format:%d"), gitTags.contains("tag: \(self.version)") else {
+        guard let gitTags = try await sys.git().log(.maxCount(1), .pretty("format:%d")).output(currentPlatform), gitTags.contains("tag: \(self.version)") else {
             throw Error(message: "Git repo is not yet tagged for release \(self.version). Please tag this commit with that version and push it to GitHub.")
         }
 
         do {
-            try runProgram(git, "diff-index", "--quiet", "HEAD")
+            try await sys.git().diffIndex(.quiet, treeIsh: "HEAD").run(currentPlatform)
         } catch {
             throw Error(message: "Git repo has local changes. First commit these changes, tag the commit with release \(self.version) and push the tag to GitHub.")
         }