Merge branch 'main' into add-checkout-remote-tracking

Author: tib

.github/workflows/test.yml

@@ -0,0 +1,24 @@
+name: Test
+on:
+  push:
+    branches:
+      - main
+
+  pull_request:
+    paths:
+      - "Sources/**"
+      - "Tests/**"
+      - ".github/workflows/test.yml"
+
+jobs:
+  test:
+    name: Run tests
+    runs-on: macos-15
+    steps:
+      - uses: actions/checkout@v4
+
+      # there are unit tests that rely on the default branch name being `main` but this isn't the case on GitHub Actions runners
+      - name: Set Git default branch name
+        run: git config --global init.defaultBranch main
+
+      - run: make test

Makefile

@@ -0,0 +1,3 @@
+.PHONY: test
+test:
+	swift test

Sources/GitKit/Git.swift

@@ -16,8 +16,9 @@ public final class Git: Shell {
         case cmd(Command, String? = nil)
         case addAll
         case status(short: Bool = false)
-        case commit(message: String, Bool = false)
-        case config(name: String, value: String)
+        case commit(message: String, allowEmpty: Bool = false, gpgSigned: Bool = false)
+        case writeConfig(name: String, value: String)
+        case readConfig(name: String)
         case clone(url: String)
 
         /// - parameter branch the name of the branch to checkout
@@ -37,7 +38,11 @@ public final class Git: Shell {
         case submoduleForeach(recursive: Bool = false, command: String)
         case renameRemote(oldName: String, newName: String)
         case addRemote(name: String, url: String)
-        case revParse(abbrevRef: String)
+
+        /// - parameter abbrevRef whether or not the result should be the abbreviated reference name or the full commit SHA hash
+        /// - parameter revision the name of the revision to parse. can be symbolic (`@`), human-readable (`origin/HEAD`) or a commit SHA hash
+        case revParse(abbrevRef: Bool, revision: String)
+
         case revList(branch: String, count: Bool = false, revisions: String? = nil)
         case raw(String)
         case lsRemote(url: String, limitToHeads: Bool = false)
@@ -57,11 +62,16 @@ public final class Git: Shell {
                 if short {
                     params.append("--short")
                 }
-            case .commit(let message, let allowEmpty):
+            case .commit(let message, let allowEmpty, let gpgSigned):
                 params = [Command.commit.rawValue, "-m", "\"\(message)\""]
                 if allowEmpty {
                     params.append("--allow-empty")
                 }
+                if gpgSigned {
+                    params.append("--gpg-sign")
+                } else {
+                    params.append("--no-gpg-sign")
+                }
             case .clone(let url):
                 params = [Command.clone.rawValue, url]
             case .checkout(let branch, let create, let tracking):
@@ -143,10 +153,10 @@ public final class Git: Shell {
                 params = [Command.remote.rawValue, "add", name, url]
             case .raw(let command):
                 params.append(command)
-            case .config(name: let name, value: let value):
+            case .writeConfig(let name, let value):
                 params = [Command.config.rawValue, "--add", name, value]
-            case .revParse(abbrevRef: let abbrevRef):
-                params = [Command.revParse.rawValue, "--abbrev-ref", abbrevRef]
+            case .readConfig(let name):
+                params = [Command.config.rawValue, "--get", name]
             case .revList(let branch, let count, let revisions):
                 params = [Command.revList.rawValue]
                 if count {
@@ -155,6 +165,12 @@ public final class Git: Shell {
                 if let revisions = revisions {
                     params.append(revisions)
                 }
+            case .revParse(let abbrevRef, let revision):
+                params = [Command.revParse.rawValue]
+                if abbrevRef {
+                    params.append("--abbrev-ref")
+                }
+                params.append(revision)
             case .lsRemote(url: let url, limitToHeads: let limitToHeads):
                 params = [Command.lsRemote.rawValue]
                 if limitToHeads {

Tests/GitKitTests/GitKitTests.swift

@@ -26,6 +26,7 @@ final class GitKitTests: XCTestCase {
         ("testCommandWithArgs", testCommandWithArgs),
         ("testClone", testClone),
         ("testCheckoutRemoteTracking", testCheckoutRemoteTracking),
+        ("testRevParse", testRevParse),
     ]
 
     // MARK: - helpers
@@ -50,7 +51,7 @@ final class GitKitTests: XCTestCase {
         try self.clean(path: path)
         let expectedOutput = expectation
         let git = Git(path: path)
-        try git.run(.raw("init && git commit -m 'initial' --allow-empty"))
+        try git.run(.raw("init && git commit -m 'initial' --allow-empty --no-gpg-sign"))
         let output = try git.run(alias)
         self.assert(type: "output", result: output, expected: expectedOutput)
         try self.clean(path: path)
@@ -74,44 +75,39 @@ final class GitKitTests: XCTestCase {
         try self.clean(path: path)
         let git = Git(path: path)
         try git.run(.cmd(.initialize))
-        try git.run(.commit(message: expectation, true))
-        let out = try git.run(.log(1))
+        try git.run(.commit(message: expectation, allowEmpty: true))
+        let out = try git.run(.log(numberOfCommits: 1))
         try self.clean(path: path)
         XCTAssertTrue(out.hasSuffix(expectation), "Commit was not created.")
     }
 
     func testCommandWithArgs() throws {
         let path = self.currentPath()
 
-        try self._test(.cmd(.branch, "-a"), path: path, expectation: "* master")
+        try self._test(.cmd(.branch, "-a"), path: path, expectation: "* main")
     }
 
     func testClone() throws {
         let path = self.currentPath()
 
         let expectation = """
-            On branch master
-            Your branch is up to date with 'origin/master'.
+            On branch main
+            Your branch is up to date with 'origin/main'.
 
             nothing to commit, working tree clean
             """
 
         try self.clean(path: path)
         let git = Git(path: path)
 
-        try git.run(.clone(url: "git@github.com:binarybirds/shell-kit"))
+        try git.run(.clone(url: "https://github.com/binarybirds/shell-kit.git"))
         let statusOutput = try git.run("cd \(path)/shell-kit && git status")
         try self.clean(path: path)
         self.assert(type: "output", result: statusOutput, expected: expectation)
     }
 
     func testCheckoutRemoteTracking() throws {
-        let path = self.currentPath()
-        
-        try self.clean(path: path)
-        let git = Git(path: path)
-
-        try git.run(.clone(url: "https://github.com/binarybirds/shell-kit.git"))
+      try git.run(.clone(url: "https://github.com/binarybirds/shell-kit.git"))
 
         let repoPath = "\(path)/shell-kit"
         let repoGit = Git(path: repoPath)
@@ -124,17 +120,43 @@ final class GitKitTests: XCTestCase {
         XCTAssertTrue(branchOutput.contains("origin/main"), "Branch should track origin/main")
     }
 
+    func testRevParse() throws {
+
+        let path = self.currentPath()
+        
+        try self.clean(path: path)
+        let git = Git(path: path)
+
+        try git.run(.raw("init"))
+        try git.run(.commit(message: "initial commit", allowEmpty: true))
+
+        let abbrevRef = try git.run(.revParse(abbrevRef: true, revision: "HEAD"))
+        XCTAssertEqual(abbrevRef, "main", "Should return abbreviated reference name")
+
+        let fullSHA = try git.run(.revParse(abbrevRef: false, revision: "HEAD"))
+        XCTAssertTrue(fullSHA.count == 40, "Should return full 40-character SHA")
+        XCTAssertTrue(fullSHA.allSatisfy { $0.isHexDigit }, "SHA should contain only hex characters")
+
+        let symbolicRef = try git.run(.revParse(abbrevRef: false, revision: "@"))
+        XCTAssertEqual(symbolicRef, fullSHA, "Symbolic '@' should resolve to same SHA as HEAD")
+
+        let currentBranch = try git.run(.revParse(abbrevRef: true, revision: "@"))
+        XCTAssertEqual(currentBranch, "main", "Should return current branch name")
+
+        try self.clean(path: path)
+    }
+
     #if os(macOS)
     func testAsyncRun() throws {
         let path = self.currentPath()
         try self.clean(path: path)
         let expectedOutput = """
-            On branch master
+            On branch main
             nothing to commit, working tree clean
             """
 
         let git = Git(path: path)
-        try git.run(.raw("init && git commit -m 'initial' --allow-empty"))
+        try git.run(.raw("init && git commit -m 'initial' --allow-empty --no-gpg-sign"))
 
         let expectation = XCTestExpectation(description: "Shell command finished.")
         git.run(.cmd(.status)) { result, error in