feat: adds function for checking out a git ref (#160)

Author: jmgilman

lib/tools/git/repo/repo.go

@@ -6,6 +6,7 @@ import (
 	"log/slog"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 
 	gg "github.com/go-git/go-git/v5"
@@ -43,18 +44,62 @@ type GitRepo struct {
 	worktree     *gg.Worktree
 }
 
+// CheckoutBranch checks out a branch with the given name.
+func (g *GitRepo) CheckoutBranch(branch string) error {
+	return g.worktree.Checkout(&gg.CheckoutOptions{
+		Branch: plumbing.NewBranchReferenceName(branch),
+	})
+}
+
 // CheckoutCommit checks out a commit with the given hash.
 func (g *GitRepo) CheckoutCommit(hash string) error {
 	return g.worktree.Checkout(&gg.CheckoutOptions{
 		Hash: plumbing.NewHash(hash),
 	})
 }
 
-// CheckoutBranch checks out a branch with the given name.
-func (g *GitRepo) CheckoutBranch(branch string) error {
-	return g.worktree.Checkout(&gg.CheckoutOptions{
-		Branch: plumbing.NewBranchReferenceName(branch),
-	})
+func (g *GitRepo) CheckoutRef(reference string) error {
+	// Initialize checkout options
+	checkoutOpts := &gg.CheckoutOptions{
+		Force: true,
+	}
+
+	// Try as a commit hash first
+	hash := plumbing.NewHash(reference)
+	if !hash.IsZero() {
+		_, err := g.raw.CommitObject(hash)
+		if err == nil {
+			checkoutOpts.Hash = hash
+			return g.worktree.Checkout(checkoutOpts)
+		}
+	}
+
+	// Try as a local branch
+	branchRefName := plumbing.NewBranchReferenceName(reference)
+	_, err := g.raw.Reference(branchRefName, true)
+	if err == nil {
+		checkoutOpts.Branch = branchRefName
+		return g.worktree.Checkout(checkoutOpts)
+	}
+
+	// Try as a tag
+	tagRefName := plumbing.NewTagReferenceName(reference)
+	tagRef, err := g.raw.Reference(tagRefName, true)
+	if err == nil {
+		tagObj, err := g.raw.TagObject(tagRef.Hash())
+		if err == nil {
+			commit, err := tagObj.Commit()
+			if err == nil {
+				checkoutOpts.Hash = commit.Hash
+				return g.worktree.Checkout(checkoutOpts)
+			}
+		} else if strings.Contains(err.Error(), "not a tag object") {
+			checkoutOpts.Hash = tagRef.Hash()
+			return g.worktree.Checkout(checkoutOpts)
+		}
+	}
+
+	return fmt.Errorf("reference not found: %s is not a valid commit hash, branch, or tag", reference)
 }
 
 // Clone loads a repository from a git remote.
@@ -104,6 +149,36 @@ func (g *GitRepo) Commit(msg string) (plumbing.Hash, error) {
 	return hash, nil
 }
 
+// CreateTag creates a tag with the given name and message.
+func (g *GitRepo) CreateTag(name, hash, message string) error {
+	commitHash := plumbing.NewHash(hash)
+	if commitHash.IsZero() {
+		return fmt.Errorf("invalid commit hash: %s", hash)
+	}
+
+	_, err := g.raw.CommitObject(commitHash)
+	if err != nil {
+		return fmt.Errorf("failed to find commit %s: %w", hash, err)
+	}
+
+	author, email := g.getAuthor()
+	opts := &gg.CreateTagOptions{
+		Message: message,
+		Tagger: &object.Signature{
+			Name:  author,
+			Email: email,
+			When:  time.Now(),
+		},
+	}
+
+	_, err = g.raw.CreateTag(name, commitHash, opts)
+	if err != nil {
+		return fmt.Errorf("failed to create tag %s: %w", name, err)
+	}
+
+	return nil
+}
+
 // Exists checks if a file exists in the repository.
 func (g *GitRepo) Exists(path string) (bool, error) {
 	_, err := g.wfs.Stat(path)

lib/tools/git/repo/repo_test.go

@@ -55,6 +55,66 @@ func TestGitRepoClone(t *testing.T) {
 	assert.Equal(t, commit.Message, "test")
 }
 
+func TestGitRepoCheckoutRef(t *testing.T) {
+	t.Run("valid commit", func(t *testing.T) {
+		repo := newGitRepo(t)
+		oldHead, err := repo.raw.Head()
+		require.NoError(t, err)
+
+		require.NoError(t, repo.wfs.WriteFile("new.txt", []byte("test"), 0644))
+		require.NoError(t, repo.StageFile("new.txt"))
+		hash, err := repo.Commit("test")
+		require.NoError(t, err)
+		newHead, err := repo.raw.CommitObject(hash)
+		require.NoError(t, err)
+		require.NotEqual(t, oldHead.Hash(), newHead.Hash)
+
+		assert.NoError(t, repo.CheckoutRef(oldHead.Hash().String()))
+		head, err := repo.raw.Head()
+		require.NoError(t, err)
+		assert.Equal(t, head.Hash(), oldHead.Hash())
+	})
+
+	t.Run("valid branch", func(t *testing.T) {
+		repo := newGitRepo(t)
+		require.NoError(t, repo.NewBranch("test"))
+		require.NoError(t, repo.wfs.WriteFile("new.txt", []byte("test"), 0644))
+		require.NoError(t, repo.StageFile("new.txt"))
+		_, err := repo.Commit("test")
+		require.NoError(t, err)
+
+		assert.NoError(t, repo.CheckoutRef("master"))
+		branch, err := repo.GetCurrentBranch()
+		require.NoError(t, err)
+		assert.Equal(t, branch, "master")
+	})
+
+	t.Run("valid tag", func(t *testing.T) {
+		repo := newGitRepo(t)
+		head, err := repo.raw.Head()
+		require.NoError(t, err)
+		require.NoError(t, repo.CreateTag("v1.0.0", head.Hash().String(), "test tag"))
+
+		require.NoError(t, repo.wfs.WriteFile("new.txt", []byte("test"), 0644))
+		require.NoError(t, repo.StageFile("new.txt"))
+		_, err = repo.Commit("test")
+		require.NoError(t, err)
+
+		assert.NoError(t, repo.CheckoutRef("v1.0.0"))
+
+		newHead, err := repo.raw.Head()
+		require.NoError(t, err)
+		assert.Equal(t, head.Hash().String(), newHead.Hash().String())
+	})
+
+	t.Run("invalid ref", func(t *testing.T) {
+		repo := newGitRepo(t)
+
+		err := repo.CheckoutRef("invalid")
+		assert.Error(t, err)
+	})
+}
+
 func TestGitRepoCommit(t *testing.T) {
 	t.Run("succcess", func(t *testing.T) {
 		repo := newGitRepo(t)
@@ -73,6 +133,37 @@ func TestGitRepoCommit(t *testing.T) {
 	})
 }
 
+func TestGitRepoCreateTag(t *testing.T) {
+	t.Run("create annotated tag", func(t *testing.T) {
+		repo := newGitRepo(t)
+
+		require.NoError(t, repo.wfs.WriteFile("new.txt", []byte("contesttent"), 0644))
+		require.NoError(t, repo.StageFile("new.txt"))
+		commitHash, err := repo.Commit("test")
+		require.NoError(t, err)
+
+		err = repo.CreateTag("v1.0.0", commitHash.String(), "message")
+		assert.NoError(t, err)
+
+		tag, err := repo.raw.Tag("v1.0.0")
+		require.NoError(t, err)
+
+		tagObj, err := repo.raw.TagObject(tag.Hash())
+		require.NoError(t, err, "Should be able to get a tag object for an annotated tag")
+		assert.Equal(t, "message\n", tagObj.Message)
+
+		commit, err := tagObj.Commit()
+		require.NoError(t, err)
+		assert.Equal(t, commitHash.String(), commit.Hash.String())
+	})
+
+	t.Run("invalid commit hash", func(t *testing.T) {
+		repo := newGitRepo(t)
+		err := repo.CreateTag("invalid-tag", "not-a-hash", "")
+		assert.Error(t, err)
+	})
+}
+
 func TestGitRepoFetch(t *testing.T) {
 	var opts *gg.FetchOptions
 	repo := newGitRepo(t)