add -debug and use git status

Author: linkdata

main.go

@@ -28,6 +28,7 @@ var (
 	flagGit       = flag.String("git", "git", "path to Git executable")
 	flagOut       = flag.String("out", "", "write to file instead of stdout (relative paths are relative to repo)")
 	flagName      = flag.String("name", "", "override the Go PkgName, default is to use last portion of module in go.mod")
+	flagDebug     = flag.Bool("debug", false, "write debug info to stderr")
 	flagGoPackage = flag.Bool("gopackage", false, "write Go source with PkgName and PkgVersion")
 	flagNoFetch   = flag.Bool("nofetch", false, "don't fetch remote tags")
 	flagNoNewline = flag.Bool("nonewline", false, "don't print a newline after the output")
@@ -42,6 +43,9 @@ func mainfn() int {
 
 	vs, err := gitsemver.New(*flagGit)
 	if err == nil {
+		if *flagDebug {
+			vs.DebugOut = os.Stderr
+		}
 		var createTag string
 		if repoDir, err = vs.Git.CheckGitRepo(repoDir); err == nil {
 			if !*flagNoFetch {

main_test.go

@@ -35,6 +35,7 @@ func TestMainError(t *testing.T) {
 	}
 	flag.Parse()
 	*flagOut = "/proc/.nonexistant"
+	*flagDebug = true
 	*flagIncPatch = true
 	main()
 }

pkg/gitsemver.go

@@ -1,13 +1,16 @@
 package gitsemver
 
 import (
+	"fmt"
+	"io"
 	"strconv"
 	"strings"
 )
 
 type GitSemVer struct {
-	Git Gitter      // Git
-	Env Environment // environment
+	Git      Gitter      // Git
+	Env      Environment // environment
+	DebugOut io.Writer   // if nit nil, write debug output here
 }
 
 // New returns a GitSemVer ready to examine
@@ -62,27 +65,49 @@ func (vs *GitSemVer) IsReleaseBranch(branchName string) bool {
 	return false
 }
 
+// Debug writes debugging output to DebugOut if it's not nil.
+func (vs *GitSemVer) Debug(f string, args ...any) {
+	if vs.DebugOut != nil {
+		_, _ = fmt.Fprintf(vs.DebugOut, f, args...)
+	}
+}
+
 // GetTag returns the semver git version tag matching the current tree, or
-// the closest semver tag if none match.
+// the closest semver tag if none match exactly. It also returns a bool
+// that is true if the tree hashes match and there are no uncommitted changes.
 func (vs *GitSemVer) GetTag(repo string) (string, bool) {
 	if tag := strings.TrimSpace(vs.Env.Getenv("CI_COMMIT_TAG")); tag != "" {
 		return tag, true
 	}
-	if currtreehash := vs.Git.GetCurrentTreeHash(repo); currtreehash != "" {
+	treehashes := map[string]string{}
+	cleanstatus := vs.Git.CleanStatus(repo)
+	currtreehash := vs.Git.GetCurrentTreeHash(repo)
+	if currtreehash != "" {
+		vs.Debug("treehash %s: HEAD (clean: %v)\n", currtreehash, cleanstatus)
 		for _, testtag := range vs.Git.GetTags(repo) {
 			tagtreehash := vs.Git.GetTreeHash(repo, testtag)
+			if _, ok := treehashes[tagtreehash]; !ok {
+				treehashes[tagtreehash] = testtag
+			}
+			vs.Debug("treehash %s: %q\n", tagtreehash, testtag)
 			if tagtreehash == currtreehash {
-				return testtag, true
+				return testtag, cleanstatus
 			}
 		}
 	}
 	if tag := vs.Git.GetClosestTag(repo, "HEAD"); tag != "" {
-		return tag, false
+		tagtreehash := vs.Git.GetTreeHash(repo, tag)
+		if lasttag, ok := treehashes[tagtreehash]; ok {
+			tag = lasttag
+		}
+		vs.Debug("treehash %s: %q is closest to HEAD\n", tagtreehash, tag)
+		return tag, cleanstatus && (tagtreehash == currtreehash)
 	}
 	return "v0.0.0", false
 }
 
 func (vs *GitSemVer) getBranchGitHub(repo string) (branchName string) {
+	//
 	if branchName = strings.TrimSpace(vs.Env.Getenv("GITHUB_REF_NAME")); branchName != "" {
 		if strings.TrimSpace(vs.Env.Getenv("GITHUB_REF_TYPE")) == "tag" {
 			for _, branchName = range vs.Git.GetBranchesFromTag(repo, branchName) {

pkg/gitsemver_test.go

@@ -1,6 +1,7 @@
 package gitsemver_test
 
 import (
+	"bytes"
 	"testing"
 
 	gitsemver "github.com/linkdata/gitsemver/pkg"
@@ -27,12 +28,14 @@ func Test_NewVersionStringer_FailsWithBadBinary(t *testing.T) {
 }
 
 func isEqual[T comparable](t *testing.T, a, b T) {
+	t.Helper()
 	if a != b {
 		t.Errorf("%v != %v", a, b)
 	}
 }
 
 func isTrue(t *testing.T, v bool) {
+	t.Helper()
 	if !v {
 		t.Error(v)
 	}
@@ -242,3 +245,16 @@ func Test_VersionStringer_GetVersionDetachedHEAD(t *testing.T) {
 	}
 	isEqual(t, "v2.0.0", vi.Version())
 }
+
+func TestGitSemVer_Debug(t *testing.T) {
+	vs, err := gitsemver.New("git")
+	if err != nil {
+		t.Error(err)
+	}
+	var buf bytes.Buffer
+	vs.DebugOut = &buf
+	vs.Debug("foo")
+	if x := buf.String(); x != "foo" {
+		t.Error(x)
+	}
+}

pkg/gitter.go

@@ -38,10 +38,25 @@ type Gitter interface {
 	DeleteTag(repo, tag string) (err error)
 	// PushTag pushes the given tag to the origin. Does nothing if tag is empty.
 	PushTag(repo, tag string) (err error)
+	// CleanStatus returns true if there are no uncommitted changes in the repo
+	CleanStatus(repo string) bool
 }
 
 type DefaultGitter string
 
+func (dg DefaultGitter) execKeepError(args ...string) (err error) {
+	var b []byte
+	b, err = exec.Command(string(dg), args...).CombinedOutput() /* #nosec G204 */
+	if err != nil {
+		errText := err.Error()
+		if s := strings.TrimSpace(string(b)); s != "" {
+			errText = s
+		}
+		err = fmt.Errorf("%s %s: %q", string(dg), strings.Join(args, " "), errText)
+	}
+	return
+}
+
 func NewDefaultGitter(gitBin string) (gitter Gitter, err error) {
 	if gitBin, err = exec.LookPath(gitBin); err == nil {
 		gitter = DefaultGitter(gitBin)
@@ -122,7 +137,7 @@ func (dg DefaultGitter) GetTreeHash(repo, tag string) string {
 
 // GetClosestTag returns the closest semver tag for the given commit hash.
 func (dg DefaultGitter) GetClosestTag(repo, commit string) (tag string) {
-	_ = exec.Command(string(dg), "-C", repo, "fetch", "--unshallow").Run() //#nosec G204
+	_ = exec.Command(string(dg), "-C", repo, "fetch", "--unshallow", "--tags").Run() //#nosec G204
 	if b, _ := exec.Command(string(dg), "-C", repo, "describe", "--tags", "--match=v[0-9]*", "--match=[0-9]*", "--abbrev=0", commit).Output(); len(b) > 0 /* #nosec G204 */ {
 		return strings.TrimSpace(string(b))
 	}
@@ -183,25 +198,26 @@ func (dg DefaultGitter) FetchTags(repo string) (err error) {
 
 func (dg DefaultGitter) CreateTag(repo, tag string) (err error) {
 	if tag != "" {
-		err = exec.Command(string(dg), "-C", repo, "tag", tag).Run() /* #nosec G204 */
+		err = dg.execKeepError("-C", repo, "tag", tag)
 	}
 	return
 }
 
 func (dg DefaultGitter) DeleteTag(repo, tag string) (err error) {
 	if tag != "" {
-		err = exec.Command(string(dg), "-C", repo, "tag", "-d", tag).Run() /* #nosec G204 */
+		err = dg.execKeepError("-C", repo, "tag", "-d", tag)
 	}
 	return
 }
 
 func (dg DefaultGitter) PushTag(repo, tag string) (err error) {
 	if tag != "" {
-		var b []byte
-		b, err = exec.Command(string(dg), "-C", repo, "push", "origin", tag).CombinedOutput() /* #nosec G204 */
-		if err != nil {
-			err = fmt.Errorf("%w: %s", err, strings.TrimSpace(string(b)))
-		}
+		err = dg.execKeepError("-C", repo, "push", "origin", tag)
 	}
 	return
 }
+
+func (dg DefaultGitter) CleanStatus(repo string) bool {
+	b, _ := exec.Command(string(dg), "-C", repo, "status", "--untracked-files=no", "--porcelain").Output() /* #nosec G204 */
+	return len(strings.TrimSpace(string(b))) == 0
+}

pkg/gitter_test.go

@@ -221,7 +221,19 @@ func Test_DefaultGitter_PushTag(t *testing.T) {
 	err = dg.PushTag(".", "test-tag")
 	if err == nil {
 		t.Error("no error")
+	} else {
+		t.Log(err)
 	}
-	t.Log(err)
+}
 
+func Test_DefaultGitter_CleanStatus(t *testing.T) {
+	dg, err := gitsemver.NewDefaultGitter("git")
+	if err != nil {
+		t.Error(err)
+	}
+	if !dg.CleanStatus(".") {
+		t.Log("git status reports uncommitted changes")
+	} else {
+		t.Log("git status reports clean")
+	}
 }

pkg/mockgitter_test.go

@@ -38,6 +38,7 @@ type MockGitter struct {
 	branch   string
 	treehash string
 	TopTag   string
+	dirty    bool
 }
 
 func (mg *MockGitter) CheckGitRepo(dir string) (repo string, err error) {
@@ -150,4 +151,8 @@ func (mg *MockGitter) PushTag(repo, tag string) (err error) {
 	return
 }
 
+func (mg *MockGitter) CleanStatus(repo string) bool {
+	return !mg.dirty
+}
+
 var _ gitsemver.Gitter = &MockGitter{}