Refactor CommitMsg

Author: spenserblack

commit.go

@@ -5,74 +5,42 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing"
-
 	"github.com/spenserblack/git-lazy-commit/pkg/fileutils"
 )
 
-// Commit commits all changes in the repository.
-//
-// It returns the commit hash and the commit message.
-func (r *LazyRepo) Commit() (hash plumbing.Hash, msg string, err error) {
-	msg, err = r.CommitMsg()
-	if err != nil {
-		return
-	}
-
-	hash, err = r.wt.Commit(msg, &git.CommitOptions{})
-	return
-}
-
 // CommitMsg builds a commit message using the tracked files in the repository.
-func (r *LazyRepo) CommitMsg() (string, error) {
-	status, err := r.status()
+func (r Repo) CommitMsg() (string, error) {
+	statuses, err := r.Status()
 	if err != nil {
 		return "", err
 	}
-	for filename, fileStatus := range status {
-		if fileStatus.Staging == git.Unmodified || fileStatus.Staging == git.Untracked {
-			delete(status, filename)
+
+	// NOTE: Filtering to only statuses that are staged and can be used for the commit message.
+	commitableStatuses := make([]StatusRecord, 0, len(statuses))
+	for _, status := range statuses {
+		if _, ok := statusMap[status.Staged]; ok {
+			commitableStatuses = append(commitableStatuses, status)
 		}
 	}
 
-	if len(status) == 0 {
+	if len(commitableStatuses) == 0 {
 		return "", errors.New("no tracked files")
 	}
-	if len(status) == 1 {
-		for filename, fileStatus := range status {
-			return singleFileMsg(filename, fileStatus), nil
-		}
-	}
-	return multiFileMsg(status), nil
-}
 
-func singleFileMsg(filename string, fileStatus *git.FileStatus) string {
-	statusString := ""
-	switch fileStatus.Staging {
-	case git.Added:
-		statusString = "Create"
-	case git.Deleted:
-		statusString = "Delete"
-	case git.Modified:
-		statusString = "Update"
-	case git.Renamed:
-		statusString = "Rename to"
-	case git.Copied:
-		statusString = "Copy to"
-	default:
-		statusString = "Do something to"
+	if len(commitableStatuses) == 1 {
+		status := commitableStatuses[0]
+		return fmt.Sprintf("%s %s", statusMap[status.Staged], status.Path), nil
 	}
 
-	return fmt.Sprintf("%s %s", statusString, filename)
+	return multiFileMsg(commitableStatuses), nil
 }
 
-func multiFileMsg(status git.Status) string {
+// MultiFileMsg builds a commit message from multiple files.
+func multiFileMsg(statuses []StatusRecord) string {
 	var builder strings.Builder
-
-	filenames := make([]string, 0, len(status))
-	for name := range status {
-		filenames = append(filenames, name)
+	filenames := make([]string, 0, len(statuses))
+	for _, status := range statuses {
+		filenames = append(filenames, status.Path)
 	}
 
 	sharedDir := fileutils.SharedDirectory(filenames)
@@ -84,9 +52,8 @@ func multiFileMsg(status git.Status) string {
 	}
 	builder.WriteRune('\n')
 
-	for filename, fileStatus := range status {
-		msgItem := singleFileMsg(filename, fileStatus)
-		builder.WriteString(fmt.Sprintf("- %s\n", msgItem))
+	for _, status := range statuses {
+		builder.WriteString(fmt.Sprintf("- %s %s\n", statusMap[status.Staged], status.Path))
 	}
 
 	return builder.String()

commit_test.go

@@ -3,53 +3,53 @@ package lazycommit
 import (
 	"strings"
 	"testing"
-
-	gitconfig "github.com/go-git/go-git/v5/config"
 )
 
 // Tests that a commit message can't be built when there are no staged changes.
-func TestBuildCommitMessageNoStaged(t *testing.T) {
+func TestBuildCommitMessage(t *testing.T) {
+	t.Log("Creating a new repo.")
 	dir := tempRepo(t)
-	repo, err := OpenRepo(dir)
+	repo := Repo(dir)
+
+	_, err := repo.CommitMsg()
+	if err == nil && err.Error() != "no tracked files" {
+		t.Errorf(`Expected "no tracked files", got %v`, err)
+	}
+
+	f := commitFile(t, dir, "test.txt", "test")
+	defer f.Close()
+
+	t.Log(`Modifying test.txt`)
+	commitFile(t, dir, "test.txt", "")
+	addFile(t, dir, "test.txt", "different text")
+
+	msg, err := repo.CommitMsg()
 	if err != nil {
 		t.Fatal(err)
 	}
-	_, err = repo.CommitMsg()
-	if err == nil {
-		t.Fatal("expected error")
+	if msg != "Update test.txt" {
+		t.Errorf(`Expected "Update test.txt", got %v`, msg)
 	}
-}
 
-// Tests that commit commits all files in the worktree.
-func TestCommit(t *testing.T) {
-	dir := tempRepo(t)
-	updateConfig(t, dir, func(config *gitconfig.Config) {
-		config.User.Name = "Test User"
-		config.User.Email = "test@example.com"
-	})
-	addFile(t, dir, "test.txt", "test")
+	t.Log(`Adding a new file`)
 	addFile(t, dir, "test2.txt", "test")
 
-	repo, err := OpenRepo(dir)
+	msg, err = repo.CommitMsg()
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	_, msg, err := repo.Commit()
-	if err != nil {
-		t.Fatal(err)
+	lines := strings.Split(msg, "\n")
+	if lines[0] != "Update files" {
+		t.Errorf(`Expected "Update files" in the header, got %v`, lines[0])
 	}
-
-	wantHeader := "Update files"
-	wantBodyLines := []string{"- Create test.txt", "- Create test2.txt"}
-
-	if !strings.HasPrefix(msg, wantHeader) {
-		t.Errorf("expected commit message to start with %q, got %q", wantHeader, msg)
+	if lines[1] != "" {
+		t.Errorf(`Expected an empty line after the header, got %v`, lines[1])
 	}
-
-	for _, line := range wantBodyLines {
-		if !strings.Contains(msg, line) {
-			t.Errorf("expected commit message to contain %q, got %q", line, msg)
+	body := strings.Join(lines[2:], "\n")
+	t.Logf("Body:\n %v", body)
+	for _, want := range []string{"- Update test.txt", "- Create test2.txt"} {
+		if !strings.Contains(body, want) {
+			t.Errorf(`Expected %v in the body`, want)
 		}
 	}
 }

deprecated.go

@@ -1,6 +1,15 @@
-
 package lazycommit
 
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/spenserblack/git-lazy-commit/pkg/fileutils"
+)
+
 // LazyRepo is a wrapper around go-git's Repository for simpler usage.
 //
 // DEPRECATED: Use Repo instead.
@@ -25,3 +34,21 @@ func (r *LazyRepo) NoStaged() (bool, error) {
 func (r *LazyRepo) StageAll() error {
 	return r.r.StageAll()
 }
+
+// Commit commits all changes in the repository.
+//
+// It returns the commit hash and the commit message.
+func (r *LazyRepo) Commit() (hash plumbing.Hash, msg string, err error) {
+	msg, err = r.CommitMsg()
+	if err != nil {
+		return
+	}
+
+	hash, err = r.wt.Commit(msg, &git.CommitOptions{})
+	return
+}
+
+// CommitMsg builds a commit message using the tracked files in the repository.
+func (r *LazyRepo) CommitMsg() (string, error) {
+	return r.r.CommitMsg()
+}