From 28b5ac14215d0c6b9c530fcfcdc1d045764492a5 Mon Sep 17 00:00:00 2001
From: J <jimbo@Js-MacBook-Pro.local>
Date: Mon, 26 Aug 2024 11:56:35 -0400
Subject: [PATCH 1/4] feat: add ability to specify the git work directory

 - can specify via cli or with the library, work-tree and git directory values
 - created a repository object that stores work-tree and git directory values which are then used on any 'run' call to the git binary
---
 README.md                |   1 +
 internal/.DS_Store       | Bin 0 -> 6148 bytes
 internal/git/.DS_Store   | Bin 0 -> 6148 bytes
 internal/git/git.go      |  80 ++++++++++++---
 internal/git/git_test.go | 208 +++++++++++++++++++++++++++++++++------
 internal/svu/svu.go      |  17 +++-
 internal/svu/svu_test.go |  42 ++++----
 main.go                  |   7 +-
 pkg/svu/svu.go           |  12 +++
 9 files changed, 296 insertions(+), 71 deletions(-)
 create mode 100644 internal/.DS_Store
 create mode 100644 internal/git/.DS_Store

diff --git a/README.md b/README.md
index ed60a75..2c6aae2 100644
--- a/README.md
+++ b/README.md
@@ -279,6 +279,7 @@ All flags have a matching option function to configure the previous commands bey
 - `svu.Next(svu.WithTagMode(svu.AllBranches))` or `svu.Next(svu.ForAllBranches())`
 - `svu.Next(svu.WithTagMode(svu.CurrentBranch))` or `svu.Next(svu.ForCurrentBranch())`
 - `svu.Next(svu.ForcePatchIncrement())`
+- `svu.Current(svu.WithGitDirectory("/some/other/repo/.git"), svu.WithWorkTree("/some/other/repo"))`
 
 Or multiple options:
 
diff --git a/internal/.DS_Store b/internal/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..ea2933185b107004f1f71760c05436949cae83de
GIT binary patch
literal 6148
zcmeHKPm9w)6rX9U+qwujD6F@D7Y_?|mntl-5Nq|UM)aUkn@#Bk(@bg7txyU%>%}jy
zM-P4j?}8t}kKxG=;P1`6x+!%%ipYB~^Lz9DWZwKTWHL%A-JQjIN_k4DCK_R_h3+>(
zerg+1W6L&B(=+l(l$r>m&(UNfS`7ap1N83dYNQfXMDyzVOOw24x4-FHy>a2<7G!(t
zRd{UXVKFFXd3P{<L8GU}q|r(rM9-4pyzgDPZ?a;LWW%XVNa7(vUOrE<*vz|Tmc_Zv
z4V|L}>3chiMW@}_^*gt2FL(XL!G0V1!TxgDYF@p5^Ujn0n{=F+caB1h-Dc%7;|ktG
z;nl?XQ5vB-3T0C|+6#}&n78Jq(=*T5^m@E?o8M1wJiK)G>%FQs{)2aNTzRVgfV9<o
zC*d?pO*VqXRgtR`HCwMDxMt(6r&`6w$3MQjJ>)9bdsfA!cdZKbh^i0~2801&;9Lgy
zE83(pKtvc2284ks1N43H(Fg;^(xLryptDy1U;}0=&^=OsK4ZXGI)n$JT`JI}YQAD<
zmkztnaRFoL(4{NQmk-S|YrdgqJ3F55+i;}=htdlJ!oWHMbvN|r{C{x%{eL}4M#6wF
z@Lw^Y8@;gC#gh1J-B=u*wLaQwG!lv{9sWvzVvl0P(owvFW(9Vi6kxzuI)nuxKLVBp
K>4bs5%D_+9D}y)y

literal 0
HcmV?d00001

diff --git a/internal/git/.DS_Store b/internal/git/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..b6aacf7a1f681d254b8d91d46079d8d8620344a7
GIT binary patch
literal 6148
zcmeHKF;2r!47DLc1WU(`{{%=q0Me%lC+N@>l}asAt8^%0&Bir2027DcTs+$!lqf1=
z2Y8nJU%u^^pS&TCMMUS%>zT+zL~6L9yxKB0%bSnvqC_g7+C6rg+2XO?A4Zj@1IDf7
zMmF*!$07gYy`S5+O|#myE5z!Td|Y1Le%=l9>tFMSZSUFi4OAKxpaN8Y3Q&Q6sQ`Mm
zS$!SIl?qS+D)6I#eIF9sFc<6s{nLTPM*yJx#=GI#X9-}k05BKq0ug~}P=P_!GGb`Z
z5l^Kq7wiIqF6t-aKILRB6N>ujh$k->&4FC002LT2a2eZ)_5XYLiTQs>;*JVXfj^~y
zR?VWB<CRKp9lf0O+5~@qe;aDO9E-PNptoXdtQAjtb;+)g&jq_crz7rkAb$i*7aA2f
GhXP-Ew<nnZ

literal 0
HcmV?d00001

diff --git a/internal/git/git.go b/internal/git/git.go
index 471119d..90f57b1 100644
--- a/internal/git/git.go
+++ b/internal/git/git.go
@@ -3,7 +3,9 @@ package git
 import (
 	"errors"
 	"fmt"
+	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 
 	"github.com/gobwas/glob"
@@ -16,26 +18,68 @@ const (
 
 // copied from goreleaser
 
-// IsRepo returns true if current folder is a git repository
-func IsRepo() bool {
-	out, err := run("rev-parse", "--is-inside-work-tree")
-	return err == nil && strings.TrimSpace(out) == "true"
+type Repository struct {
+	WorkTree     string
+	GitDirectory string
 }
 
-func getAllTags(args ...string) ([]string, error) {
-	tags, err := run(append([]string{"-c", "versionsort.suffix=-", "tag", "--sort=-version:refname"}, args...)...)
+// NewRepository creates a Repository. worktree and gitdirectory will default to 'pwd' and 'pwd/.git'
+func NewRepository(worktree, gitdirectory string) (*Repository, error) {
+	var wt string
+	var err error
+	if worktree == "" {
+		wt, err = os.Getwd()
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		wt = filepath.Clean(worktree)
+	}
+	var gd string
+	if gitdirectory == "" {
+		gd, err = os.Getwd()
+		if err != nil {
+			return nil, err
+		}
+		gd = gd + string(os.PathSeparator) + ".git"
+	} else {
+		gd = filepath.Clean(gitdirectory)
+	}
+
+	r := &Repository{
+		WorkTree:     wt,
+		GitDirectory: gd,
+	}
+	return r, nil
+}
+
+// IsRepo returns true if the current work-tree and git-dir are considered a git repository by the git binary.
+// unless specified by --work-tree and --git-dir, the current working directory will be considered
+func (r *Repository) IsRepo() bool {
+	_, err := r.run("status")
+	return err == nil
+}
+
+// Root returns the root of the git Repository
+func (r *Repository) Root() (string, error) {
+	out, err := r.run("rev-parse", "--show-toplevel")
+	return strings.TrimSpace(out), err
+}
+
+func (r *Repository) getAllTags(args ...string) ([]string, error) {
+	tags, err := r.run(append([]string{"-c", "versionsort.suffix=-", "tag", "--sort=-version:refname"}, args...)...)
 	if err != nil {
 		return nil, err
 	}
 	return strings.Split(tags, "\n"), nil
 }
 
-func DescribeTag(tagMode string, pattern string) (string, error) {
+func (r *Repository) DescribeTag(tagMode string, pattern string) (string, error) {
 	args := []string{}
 	if tagMode == CurrentBranchTagMode {
 		args = []string{"--merged"}
 	}
-	tags, err := getAllTags(args...)
+	tags, err := r.getAllTags(args...)
 	if err != nil {
 		return "", err
 	}
@@ -59,17 +103,21 @@ func DescribeTag(tagMode string, pattern string) (string, error) {
 	return "", fmt.Errorf("no tags match '%s'", pattern)
 }
 
-func Changelog(tag string, dir string) (string, error) {
+func (r *Repository) Changelog(tag string, dir string) (string, error) {
 	if tag == "" {
-		return gitLog(dir, "HEAD")
+		return r.gitLog(dir, "HEAD")
 	} else {
-		return gitLog(dir, fmt.Sprintf("tags/%s..HEAD", tag))
+		return r.gitLog(dir, fmt.Sprintf("tags/%s..HEAD", tag))
 	}
 }
 
-func run(args ...string) (string, error) {
-	extraArgs := []string{
-		"-c", "log.showSignature=false",
+func (r *Repository) run(args ...string) (string, error) {
+	extraArgs := []string{"-c", "log.showSignature=false"}
+	if r.WorkTree != "" {
+		extraArgs = append(extraArgs, fmt.Sprintf("--work-tree=%s", r.WorkTree))
+	}
+	if r.GitDirectory != "" {
+		extraArgs = append(extraArgs, fmt.Sprintf("--git-dir=%s", r.GitDirectory))
 	}
 	args = append(extraArgs, args...)
 	/* #nosec */
@@ -81,11 +129,11 @@ func run(args ...string) (string, error) {
 	return string(bts), nil
 }
 
-func gitLog(dir string, refs ...string) (string, error) {
+func (r *Repository) gitLog(dir string, refs ...string) (string, error) {
 	args := []string{"log", "--no-decorate", "--no-color"}
 	args = append(args, refs...)
 	if dir != "" {
 		args = append(args, "--", dir)
 	}
-	return run(args...)
+	return r.run(args...)
 }
diff --git a/internal/git/git_test.go b/internal/git/git_test.go
index e7be156..2a40e18 100644
--- a/internal/git/git_test.go
+++ b/internal/git/git_test.go
@@ -10,25 +10,66 @@ import (
 	"github.com/matryer/is"
 )
 
-func TestIsRepo(t *testing.T) {
+func TestNewRepository(t *testing.T) {
+	cwd := currentWorkingDirectory(t)
+	cgd := cwd + string(os.PathSeparator) + ".git"
+
+	t.Run("defaults", func(t *testing.T) {
+		is := is.New(t)
+		r, err := NewRepository("", "")
+		is.NoErr(err)
+		is.Equal(r.WorkTree, cwd)
+		is.Equal(r.GitDirectory, cgd)
+	})
+
+	t.Run("only worktree set", func(t *testing.T) {
+		wt := "/idk/some/work/tree/location"
+		is := is.New(t)
+		r, err := NewRepository(wt, "")
+		is.NoErr(err)
+		is.Equal(r.WorkTree, wt)
+		is.Equal(r.GitDirectory, cgd)
+	})
+
+	t.Run("only gitdir set", func(t *testing.T) {
+		gd := "/idk/some/git/location"
+		is := is.New(t)
+		r, err := NewRepository("", gd)
+		is.NoErr(err)
+		is.Equal(r.WorkTree, cwd)
+		is.Equal(r.GitDirectory, gd)
+	})
+
+	t.Run("worktree and gitdir set", func(t *testing.T) {
+		is := is.New(t)
+		r, err := NewRepository(cwd, cgd)
+		is.NoErr(err)
+		is.Equal(r.WorkTree, cwd)
+		is.Equal(r.GitDirectory, cgd)
+	})
+}
+
+func TestRepository_IsRepo(t *testing.T) {
 	t.Run("is not a repo", func(t *testing.T) {
-		tempdir(t)
+		tempdir(t, true)
+		r := Repository{}
 		is := is.New(t)
-		is.Equal(false, IsRepo()) // should not be arepo
+		is.Equal(false, r.IsRepo()) // should not be arepo
 	})
 
 	t.Run("is a repo", func(t *testing.T) {
-		tempdir(t)
+		tempdir(t, true)
 		gitInit(t)
+		r := Repository{}
 		is := is.New(t)
-		is.True(IsRepo()) // should be arepo
+		is.True(r.IsRepo()) // should be arepo
 	})
 }
 
-func TestDescribeTag(t *testing.T) {
+func TestRepository_DescribeTag(t *testing.T) {
 	setup := func(tb testing.TB) {
 		tb.Helper()
-		tempdir(tb)
+		tempdir(tb, true)
 		gitInit(tb)
 		gitCommit(tb, "chore: foobar")
 		gitTag(tb, "pattern-1.2.3")
@@ -49,7 +90,8 @@ func TestDescribeTag(t *testing.T) {
 	t.Run("normal", func(t *testing.T) {
 		setup(t)
 		is := is.New(t)
-		tag, err := DescribeTag("current-branch", "")
+		r := Repository{}
+		tag, err := r.DescribeTag("current-branch", "")
 		is.NoErr(err)
 		is.Equal("v1.2.4", tag)
 	})
@@ -57,7 +99,8 @@ func TestDescribeTag(t *testing.T) {
 	t.Run("all-branches", func(t *testing.T) {
 		setup(t)
 		is := is.New(t)
-		tag, err := DescribeTag("all-branches", "")
+		r := Repository{}
+		tag, err := r.DescribeTag("all-branches", "")
 		is.NoErr(err)
 		is.Equal("v1.2.5", tag)
 	})
@@ -65,14 +108,15 @@ func TestDescribeTag(t *testing.T) {
 	t.Run("pattern", func(t *testing.T) {
 		setup(t)
 		is := is.New(t)
-		tag, err := DescribeTag("current-branch", "pattern-*")
+		r := Repository{}
+		tag, err := r.DescribeTag("current-branch", "pattern-*")
 		is.NoErr(err)
 		is.Equal("pattern-1.2.3", tag)
 	})
 }
 
-func TestChangelog(t *testing.T) {
-	tempdir(t)
+func TestRepository_Changelog(t *testing.T) {
+	tempdir(t, true)
 	gitInit(t)
 	gitCommit(t, "chore: foobar")
 	gitCommit(t, "lalalala")
@@ -85,7 +129,8 @@ func TestChangelog(t *testing.T) {
 		gitCommit(t, msg)
 	}
 	is := is.New(t)
-	log, err := Changelog("v1.2.3", "")
+	r := Repository{}
+	log, err := r.Changelog("v1.2.3", "")
 	is.NoErr(err)
 	for _, msg := range []string{
 		"chore: foobar",
@@ -96,10 +141,11 @@ func TestChangelog(t *testing.T) {
 	}
 }
 
-func TestChangelogWithDirectory(t *testing.T) {
-	tempDir := tempdir(t)
-	localDir := dir(tempDir, t)
-	file := tempfile(t, localDir)
+func TestRepository_ChangelogWithDirectory(t *testing.T) {
+	tempDir := tempdir(t, true)
+	localDir := dir(tempDir, "a-folder", t)
+	defer func() { os.RemoveAll(localDir) }()
+	file := tempfile(t, localDir, "a-file.txt")
 	gitInit(t)
 	gitCommit(t, "chore: foobar")
 	gitCommit(t, "lalalala")
@@ -108,13 +154,105 @@ func TestChangelogWithDirectory(t *testing.T) {
 	gitAdd(t, file)
 	gitCommit(t, "chore: filtered dir")
 	is := is.New(t)
-	log, err := Changelog("v1.2.3", localDir)
+	r := Repository{}
+	log, err := r.Changelog("v1.2.3", localDir)
 	is.NoErr(err)
 
 	is.True(strings.Contains(log, "chore: filtered dir"))
 	is.True(!strings.Contains(log, "feat: foobar"))
 }
 
+func TestRepository_run(t *testing.T) {
+	// current directory: . , ./.git
+	rootWT := currentWorkingDirectory(t)
+	rootGD := rootWT + string(os.PathSeparator) + ".git"
+
+	t.Run("current directory", func(t *testing.T) {
+		is := is.New(t)
+		rootRepository := Repository{
+			WorkTree:     rootWT,
+			GitDirectory: rootGD,
+		}
+		_, err := rootRepository.run("init")
+		is.NoErr(err)
+		is.True(rootRepository.IsRepo())
+		actualRootWT, err := rootRepository.run("rev-parse", "--show-toplevel")
+		is.NoErr(err)
+		actualRootWT = strings.TrimSuffix(actualRootWT, "\n") // git adds a new line to the cli output
+		is.Equal(actualRootWT, rootWT)
+		actualGitDir, err := rootRepository.run("rev-parse", "--absolute-git-dir")
+		is.NoErr(err)
+		actualGitDir = strings.TrimSuffix(actualGitDir, "\n") // git adds a new line to the cli output
+		is.Equal(actualGitDir, rootGD)
+	})
+
+	// subdirectory: ./foo , ./foo/.git
+	subWT := dir(currentWorkingDirectory(t), "foo", t)
+	subGD := dir(subWT, ".git", t)
+
+	t.Run("subdirectory", func(t *testing.T) {
+		is := is.New(t)
+		subfolderRepository := Repository{
+			WorkTree:     subWT,
+			GitDirectory: subGD,
+		}
+		_, err := subfolderRepository.run("init")
+		is.NoErr(err)
+		is.True(subfolderRepository.IsRepo())
+		actualWT, err := subfolderRepository.run("rev-parse", "--show-toplevel")
+		is.NoErr(err)
+		actualWT = strings.TrimSuffix(actualWT, "\n") // git adds a new line to the cli output
+		is.Equal(actualWT, subWT)
+		actualGitDir, err := subfolderRepository.run("rev-parse", "--absolute-git-dir")
+		is.NoErr(err)
+		actualGitDir = strings.TrimSuffix(actualGitDir, "\n") // git adds a new line to the cli output
+		is.Equal(actualGitDir, subGD)
+	})
+
+	// external: /temp/sdfjklds , /temp/sdfjklds/.git
+	externalWT := tempdir(t, false)
+	externalGD := dir(externalWT, ".git", t)
+	tmpWTFileName := "somefile.txt"
+	tmpWTFilePath := tempfile(t, externalWT, tmpWTFileName)
+	expectedWTContent, _ := dataFromFile(tmpWTFilePath)
+	tmpGDFileName := "somefile.txt"
+	tmpGDFilePath := tempfile(t, externalGD, tmpGDFileName)
+	expectedGDContent, _ := dataFromFile(tmpGDFilePath)
+
+	t.Run("external directory", func(t *testing.T) {
+		is := is.New(t)
+		externalRepository := Repository{
+			WorkTree:     externalWT,
+			GitDirectory: externalGD,
+		}
+		_, err := externalRepository.run("init")
+		is.NoErr(err)
+		is.True(externalRepository.IsRepo())
+		actualWT, err := externalRepository.run("rev-parse", "--show-toplevel")
+		is.NoErr(err)
+		actualWT = strings.TrimSuffix(actualWT, "\n") // git adds a new line to the cli output
+		// compare file content instead of having to deal with symlink paths
+		actualWTContent, err := dataFromFile(actualWT + string(os.PathSeparator) + tmpWTFileName)
+		is.NoErr(err)
+		is.Equal(expectedWTContent, actualWTContent)
+
+		actualGD, err := externalRepository.run("rev-parse", "--absolute-git-dir")
+		is.NoErr(err)
+		actualGD = strings.TrimSuffix(actualGD, "\n") // git adds a new line to the cli output
+		actualGDContent, err := dataFromFile(actualGD + string(os.PathSeparator) + tmpGDFileName)
+		is.NoErr(err)
+		is.Equal(expectedGDContent, actualGDContent)
+	})
+}
+
+func dataFromFile(filePath string) ([]byte, error) {
+	file, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, err
+	}
+	return file, nil
+}
+
 func switchToBranch(tb testing.TB, branch string) {
 	is := is.New(tb)
 	_, err := fakeGitRun("switch", branch)
@@ -151,31 +289,35 @@ func gitInit(tb testing.TB) {
 	is.NoErr(err)
 }
 
-func tempdir(tb testing.TB) string {
+// tempdir create a temporary directory and optionally cd into it
+func tempdir(tb testing.TB, cdToTempDir bool) string {
 	is := is.New(tb)
 	previous, err := os.Getwd()
 	is.NoErr(err)
-	tb.Cleanup(func() {
-		is.NoErr(os.Chdir(previous))
-	})
 	dir := tb.TempDir()
-	is.NoErr(os.Chdir(dir))
-	tb.Logf("cd into %s", dir)
+	if cdToTempDir {
+		tb.Cleanup(func() {
+			is.NoErr(os.Chdir(previous))
+		})
+		is.NoErr(os.Chdir(dir))
+		tb.Logf("cd into %s", dir)
+	}
 	return dir
 }
 
-func dir(tempDir string, tb testing.TB) string {
+func dir(tempDir, subfolder string, tb testing.TB) string {
 	is := is.New(tb)
-	createdDir := path.Join(tempDir, "a-folder")
+	createdDir := path.Join(tempDir, subfolder)
 	err := os.Mkdir(createdDir, 0755)
+	tb.Cleanup(func() { os.RemoveAll(createdDir) })
 	is.NoErr(err)
 	return createdDir
 }
 
-func tempfile(tb testing.TB, dir string) string {
+func tempfile(tb testing.TB, dir, filename string) string {
 	is := is.New(tb)
 	d1 := []byte("hello\ngo\n")
-	file := path.Join(dir, "a-file.txt")
+	file := path.Join(dir, filename)
 	err := os.WriteFile(file, d1, 0644)
 	is.NoErr(err)
 	return file
@@ -190,5 +332,13 @@ func fakeGitRun(args ...string) (string, error) {
 		"-c", "log.showSignature=false",
 	}
 	allArgs = append(allArgs, args...)
-	return run(allArgs...)
+	r := Repository{}
+	return r.run(allArgs...)
+}
+
+func currentWorkingDirectory(tb *testing.T) string {
+	is := is.New(tb)
+	getwd, err := os.Getwd()
+	is.NoErr(err)
+	return getwd
 }
diff --git a/internal/svu/svu.go b/internal/svu/svu.go
index 90aac80..9b81b39 100644
--- a/internal/svu/svu.go
+++ b/internal/svu/svu.go
@@ -37,10 +37,16 @@ type Options struct {
 	TagMode                   string
 	ForcePatchIncrement       bool
 	PreventMajorIncrementOnV0 bool
+	WorkTree                  string
+	GitDirectory              string
 }
 
 func Version(opts Options) (string, error) {
-	tag, err := git.DescribeTag(string(opts.TagMode), opts.Pattern)
+	r, err := git.NewRepository(opts.WorkTree, opts.GitDirectory)
+	if err != nil {
+		return "", fmt.Errorf("failed finding the repository: %w", err)
+	}
+	tag, err := r.DescribeTag(string(opts.TagMode), opts.Pattern)
 	if err != nil {
 		return "", fmt.Errorf("failed to get current tag for repo: %w", err)
 	}
@@ -51,6 +57,7 @@ func Version(opts Options) (string, error) {
 	}
 
 	result, err := nextVersion(
+		r,
 		string(opts.Cmd),
 		current,
 		tag,
@@ -70,7 +77,7 @@ func Version(opts Options) (string, error) {
 	return opts.Prefix + result.String(), nil
 }
 
-func nextVersion(cmd string, current *semver.Version, tag, preRelease, build, directory string, preventMajorIncrementOnV0, forcePatchIncrement bool) (semver.Version, error) {
+func nextVersion(r *git.Repository, cmd string, current *semver.Version, tag, preRelease, build, directory string, preventMajorIncrementOnV0, forcePatchIncrement bool) (semver.Version, error) {
 	if cmd == CurrentCmd {
 		return *current, nil
 	}
@@ -91,7 +98,7 @@ func nextVersion(cmd string, current *semver.Version, tag, preRelease, build, di
 	var err error
 	switch cmd {
 	case NextCmd, PreReleaseCmd:
-		result, err = findNextWithGitLog(current, tag, directory, preventMajorIncrementOnV0, forcePatchIncrement)
+		result, err = findNextWithGitLog(r, current, tag, directory, preventMajorIncrementOnV0, forcePatchIncrement)
 	case MajorCmd:
 		result = current.IncMajor()
 	case MinorCmd:
@@ -181,8 +188,8 @@ func getCurrentVersion(tag, prefix string) (*semver.Version, error) {
 	return current, err
 }
 
-func findNextWithGitLog(current *semver.Version, tag string, directory string, preventMajorIncrementOnV0, forcePatchIncrement bool) (semver.Version, error) {
-	log, err := git.Changelog(tag, directory)
+func findNextWithGitLog(r *git.Repository, current *semver.Version, tag string, directory string, preventMajorIncrementOnV0, forcePatchIncrement bool) (semver.Version, error) {
+	log, err := r.Changelog(tag, directory)
 	if err != nil {
 		return semver.Version{}, fmt.Errorf("failed to get changelog: %w", err)
 	}
diff --git a/internal/svu/svu_test.go b/internal/svu/svu_test.go
index 341c69f..8417718 100644
--- a/internal/svu/svu_test.go
+++ b/internal/svu/svu_test.go
@@ -1,6 +1,7 @@
 package svu
 
 import (
+	"github.com/caarlos0/svu/v2/internal/git"
 	"reflect"
 	"testing"
 
@@ -103,17 +104,18 @@ func TestFindNext(t *testing.T) {
 
 func TestCmd(t *testing.T) {
 	ver := func() *semver.Version { return semver.MustParse("1.2.3-pre+123") }
+	r := &git.Repository{}
 	t.Run(CurrentCmd, func(t *testing.T) {
 		cmd := CurrentCmd
 		t.Run("version has meta", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, ver(), "v1.2.3", "", "", "", false, false)
+			v, err := nextVersion(r, cmd, ver(), "v1.2.3", "", "", "", false, false)
 			is.NoErr(err)
 			is.Equal("1.2.3-pre+123", v.String())
 		})
 		t.Run("version is clean", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, semver.MustParse("v1.2.3"), "v1.2.3", "doesnt matter", "nope", "", false, true)
+			v, err := nextVersion(r, cmd, semver.MustParse("v1.2.3"), "v1.2.3", "doesnt matter", "nope", "", false, true)
 			is.NoErr(err)
 			is.Equal("1.2.3", v.String())
 		})
@@ -123,25 +125,25 @@ func TestCmd(t *testing.T) {
 		cmd := MinorCmd
 		t.Run("no meta", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, ver(), "v1.2.3", "", "", "", false, false)
+			v, err := nextVersion(r, cmd, ver(), "v1.2.3", "", "", "", false, false)
 			is.NoErr(err)
 			is.Equal("1.3.0", v.String())
 		})
 		t.Run("build", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, ver(), "v1.2.3", "", "124", "", false, false)
+			v, err := nextVersion(r, cmd, ver(), "v1.2.3", "", "124", "", false, false)
 			is.NoErr(err)
 			is.Equal("1.3.0+124", v.String())
 		})
 		t.Run("prerel", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, ver(), "v1.2.3", "alpha.1", "", "", false, false)
+			v, err := nextVersion(r, cmd, ver(), "v1.2.3", "alpha.1", "", "", false, false)
 			is.NoErr(err)
 			is.Equal("1.3.0-alpha.1", v.String())
 		})
 		t.Run("all meta", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, ver(), "v1.2.3", "alpha.2", "125", "", false, false)
+			v, err := nextVersion(r, cmd, ver(), "v1.2.3", "alpha.2", "125", "", false, false)
 			is.NoErr(err)
 			is.Equal("1.3.0-alpha.2+125", v.String())
 		})
@@ -151,49 +153,49 @@ func TestCmd(t *testing.T) {
 		cmd := PatchCmd
 		t.Run("no meta", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, semver.MustParse("1.2.3"), "v1.2.3", "", "", "", false, false)
+			v, err := nextVersion(r, cmd, semver.MustParse("1.2.3"), "v1.2.3", "", "", "", false, false)
 			is.NoErr(err)
 			is.Equal("1.2.4", v.String())
 		})
 		t.Run("previous had meta", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, semver.MustParse("1.2.3-alpha.1+1"), "v1.2.3", "", "", "", false, false)
+			v, err := nextVersion(r, cmd, semver.MustParse("1.2.3-alpha.1+1"), "v1.2.3", "", "", "", false, false)
 			is.NoErr(err)
 			is.Equal("1.2.3", v.String())
 		})
 		t.Run("previous had meta, force", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, semver.MustParse("1.2.3-alpha.1+1"), "v1.2.3", "", "", "", false, true)
+			v, err := nextVersion(r, cmd, semver.MustParse("1.2.3-alpha.1+1"), "v1.2.3", "", "", "", false, true)
 			is.NoErr(err)
 			is.Equal("1.2.4", v.String())
 		})
 		t.Run("previous had meta, force, add meta", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, semver.MustParse("1.2.3-alpha.1+1"), "v1.2.3-alpha.1+1", "alpha.2", "10", "", false, true)
+			v, err := nextVersion(r, cmd, semver.MustParse("1.2.3-alpha.1+1"), "v1.2.3-alpha.1+1", "alpha.2", "10", "", false, true)
 			is.NoErr(err)
 			is.Equal("1.2.4-alpha.2+10", v.String())
 		})
 		t.Run("previous had meta, change it", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, semver.MustParse("1.2.3-alpha.1+1"), "v1.2.3-alpha.1+1", "alpha.2", "10", "", false, false)
+			v, err := nextVersion(r, cmd, semver.MustParse("1.2.3-alpha.1+1"), "v1.2.3-alpha.1+1", "alpha.2", "10", "", false, false)
 			is.NoErr(err)
 			is.Equal("1.2.3-alpha.2+10", v.String())
 		})
 		t.Run("build", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, semver.MustParse("1.2.3"), "v1.2.3", "", "124", "", false, false)
+			v, err := nextVersion(r, cmd, semver.MustParse("1.2.3"), "v1.2.3", "", "124", "", false, false)
 			is.NoErr(err)
 			is.Equal("1.2.4+124", v.String())
 		})
 		t.Run("prerel", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, semver.MustParse("1.2.3"), "v1.2.3", "alpha.1", "", "", false, false)
+			v, err := nextVersion(r, cmd, semver.MustParse("1.2.3"), "v1.2.3", "alpha.1", "", "", false, false)
 			is.NoErr(err)
 			is.Equal("1.2.4-alpha.1", v.String())
 		})
 		t.Run("all meta", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, semver.MustParse("1.2.3"), "v1.2.3", "alpha.2", "125", "", false, false)
+			v, err := nextVersion(r, cmd, semver.MustParse("1.2.3"), "v1.2.3", "alpha.2", "125", "", false, false)
 			is.NoErr(err)
 			is.Equal("1.2.4-alpha.2+125", v.String())
 		})
@@ -203,25 +205,25 @@ func TestCmd(t *testing.T) {
 		cmd := MajorCmd
 		t.Run("no meta", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, ver(), "v1.2.3", "", "", "", false, false)
+			v, err := nextVersion(r, cmd, ver(), "v1.2.3", "", "", "", false, false)
 			is.NoErr(err)
 			is.Equal("2.0.0", v.String())
 		})
 		t.Run("build", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, ver(), "v1.2.3", "", "124", "", false, false)
+			v, err := nextVersion(r, cmd, ver(), "v1.2.3", "", "124", "", false, false)
 			is.NoErr(err)
 			is.Equal("2.0.0+124", v.String())
 		})
 		t.Run("prerel", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, ver(), "v1.2.3", "alpha.1", "", "", false, false)
+			v, err := nextVersion(r, cmd, ver(), "v1.2.3", "alpha.1", "", "", false, false)
 			is.NoErr(err)
 			is.Equal("2.0.0-alpha.1", v.String())
 		})
 		t.Run("all meta", func(t *testing.T) {
 			is := is.New(t)
-			v, err := nextVersion(cmd, ver(), "v1.2.3", "alpha.2", "125", "", false, false)
+			v, err := nextVersion(r, cmd, ver(), "v1.2.3", "alpha.2", "125", "", false, false)
 			is.NoErr(err)
 			is.Equal("2.0.0-alpha.2+125", v.String())
 		})
@@ -230,12 +232,12 @@ func TestCmd(t *testing.T) {
 	t.Run("errors", func(t *testing.T) {
 		t.Run("invalid build", func(t *testing.T) {
 			is := is.New(t)
-			_, err := nextVersion(MinorCmd, semver.MustParse("1.2.3"), "v1.2.3", "", "+125", "", false, false)
+			_, err := nextVersion(r, MinorCmd, semver.MustParse("1.2.3"), "v1.2.3", "", "+125", "", false, false)
 			is.True(err != nil)
 		})
 		t.Run("invalid prerelease", func(t *testing.T) {
 			is := is.New(t)
-			_, err := nextVersion(MinorCmd, semver.MustParse("1.2.3"), "v1.2.3", "+aaa", "", "", false, false)
+			_, err := nextVersion(r, MinorCmd, semver.MustParse("1.2.3"), "v1.2.3", "+aaa", "", "", false, false)
 			is.True(err != nil)
 		})
 	})
diff --git a/main.go b/main.go
index 378e969..d662a91 100644
--- a/main.go
+++ b/main.go
@@ -18,7 +18,7 @@ var (
 	currentCmd    = app.Command("current", "prints current version").Alias("c")
 	preReleaseCmd = app.Command("prerelease", "new pre release version based on the next version calculated from git log").
 			Alias("pr")
-	preRelease  = app.Flag("pre-release", "adds a pre-release suffix to the version, without the semver mandatory dash prefix").
+	preRelease = app.Flag("pre-release", "adds a pre-release suffix to the version, without the semver mandatory dash prefix").
 			String()
 	pattern     = app.Flag("pattern", "limits calculations to be based on tags matching the given pattern").String()
 	prefix      = app.Flag("prefix", "set a custom prefix").Default("v").String()
@@ -29,6 +29,9 @@ var (
 	tagMode   = app.Flag("tag-mode", "determines if latest tag of the current or all branches will be used").
 			Default("current-branch").
 			Enum("current-branch", "all-branches")
+	workTree = app.Flag("work-tree", "sets the git work-tree directory where the git repository exists").
+			Default("").String()
+	gitDirectory        = app.Flag("git-directory", "sets the directory where the .git folder exists").Default("").String()
 	forcePatchIncrement = nextCmd.Flag("force-patch-increment", "forces a patch version increment regardless of the commit message content").
 				Default("false").
 				Bool()
@@ -53,6 +56,8 @@ func main() {
 		Build:                     *build,
 		Directory:                 *directory,
 		TagMode:                   *tagMode,
+		WorkTree:                  *workTree,
+		GitDirectory:              *gitDirectory,
 		ForcePatchIncrement:       *forcePatchIncrement,
 		PreventMajorIncrementOnV0: *preventMajorIncrementOnV0,
 	})
diff --git a/pkg/svu/svu.go b/pkg/svu/svu.go
index 0b9831e..8b0fdbb 100644
--- a/pkg/svu/svu.go
+++ b/pkg/svu/svu.go
@@ -102,6 +102,18 @@ func ForcePatchIncrement() option {
 	return WithForcePatchIncrement(true)
 }
 
+func WithWorkTree(directory string) option {
+	return func(o *svu.Options) {
+		o.WorkTree = directory
+	}
+}
+
+func WithGitDirectory(directory string) option {
+	return func(o *svu.Options) {
+		o.GitDirectory = directory
+	}
+}
+
 func version(opts ...option) (string, error) {
 	options := &svu.Options{
 		Cmd:     svu.NextCmd,

From 7e0e65bec04813d5c8c50e27accbcfb7ac5e5b65 Mon Sep 17 00:00:00 2001
From: J <jimbo@Js-MacBook-Pro.local>
Date: Mon, 26 Aug 2024 12:09:05 -0400
Subject: [PATCH 2/4] chore: remove macos files

---
 internal/.DS_Store     | Bin 6148 -> 0 bytes
 internal/git/.DS_Store | Bin 6148 -> 0 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 internal/.DS_Store
 delete mode 100644 internal/git/.DS_Store

diff --git a/internal/.DS_Store b/internal/.DS_Store
deleted file mode 100644
index ea2933185b107004f1f71760c05436949cae83de..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeHKPm9w)6rX9U+qwujD6F@D7Y_?|mntl-5Nq|UM)aUkn@#Bk(@bg7txyU%>%}jy
zM-P4j?}8t}kKxG=;P1`6x+!%%ipYB~^Lz9DWZwKTWHL%A-JQjIN_k4DCK_R_h3+>(
zerg+1W6L&B(=+l(l$r>m&(UNfS`7ap1N83dYNQfXMDyzVOOw24x4-FHy>a2<7G!(t
zRd{UXVKFFXd3P{<L8GU}q|r(rM9-4pyzgDPZ?a;LWW%XVNa7(vUOrE<*vz|Tmc_Zv
z4V|L}>3chiMW@}_^*gt2FL(XL!G0V1!TxgDYF@p5^Ujn0n{=F+caB1h-Dc%7;|ktG
z;nl?XQ5vB-3T0C|+6#}&n78Jq(=*T5^m@E?o8M1wJiK)G>%FQs{)2aNTzRVgfV9<o
zC*d?pO*VqXRgtR`HCwMDxMt(6r&`6w$3MQjJ>)9bdsfA!cdZKbh^i0~2801&;9Lgy
zE83(pKtvc2284ks1N43H(Fg;^(xLryptDy1U;}0=&^=OsK4ZXGI)n$JT`JI}YQAD<
zmkztnaRFoL(4{NQmk-S|YrdgqJ3F55+i;}=htdlJ!oWHMbvN|r{C{x%{eL}4M#6wF
z@Lw^Y8@;gC#gh1J-B=u*wLaQwG!lv{9sWvzVvl0P(owvFW(9Vi6kxzuI)nuxKLVBp
K>4bs5%D_+9D}y)y

diff --git a/internal/git/.DS_Store b/internal/git/.DS_Store
deleted file mode 100644
index b6aacf7a1f681d254b8d91d46079d8d8620344a7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeHKF;2r!47DLc1WU(`{{%=q0Me%lC+N@>l}asAt8^%0&Bir2027DcTs+$!lqf1=
z2Y8nJU%u^^pS&TCMMUS%>zT+zL~6L9yxKB0%bSnvqC_g7+C6rg+2XO?A4Zj@1IDf7
zMmF*!$07gYy`S5+O|#myE5z!Td|Y1Le%=l9>tFMSZSUFi4OAKxpaN8Y3Q&Q6sQ`Mm
zS$!SIl?qS+D)6I#eIF9sFc<6s{nLTPM*yJx#=GI#X9-}k05BKq0ug~}P=P_!GGb`Z
z5l^Kq7wiIqF6t-aKILRB6N>ujh$k->&4FC002LT2a2eZ)_5XYLiTQs>;*JVXfj^~y
zR?VWB<CRKp9lf0O+5~@qe;aDO9E-PNptoXdtQAjtb;+)g&jq_crz7rkAb$i*7aA2f
GhXP-Ew<nnZ


From ac7f6e684adf43a741159066bab1cfc391e9d58e Mon Sep 17 00:00:00 2001
From: J <jimbo@Js-MacBook-Pro.local>
Date: Mon, 26 Aug 2024 16:17:10 -0400
Subject: [PATCH 3/4] refactor: @ccoVeille's comments

---
 README.md                |  2 +-
 internal/git/git.go      | 18 +++++++-----------
 internal/git/git_test.go |  6 ++++--
 internal/svu/svu.go      |  4 ++--
 main.go                  |  4 ++--
 pkg/svu/svu.go           |  4 ++--
 6 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/README.md b/README.md
index 2c6aae2..c18faa1 100644
--- a/README.md
+++ b/README.md
@@ -279,7 +279,7 @@ All flags have a matching option function to configure the previous commands bey
 - `svu.Next(svu.WithTagMode(svu.AllBranches))` or `svu.Next(svu.ForAllBranches())`
 - `svu.Next(svu.WithTagMode(svu.CurrentBranch))` or `svu.Next(svu.ForCurrentBranch())`
 - `svu.Next(svu.ForcePatchIncrement())`
-- `svu.Current(svu.WithGitDirectory("/some/other/repo/.git"), svu.WithWorkTree("/some/other/repo"))`
+- `svu.Current(svu.WithGitDirectory("/some/other/repo/.git"), svu.WithGitWorkTree("/some/other/repo"))`
 
 Or multiple options:
 
diff --git a/internal/git/git.go b/internal/git/git.go
index 90f57b1..3d5bdcd 100644
--- a/internal/git/git.go
+++ b/internal/git/git.go
@@ -25,30 +25,26 @@ type Repository struct {
 
 // NewRepository creates a Repository. worktree and gitdirectory will default to 'pwd' and 'pwd/.git'
 func NewRepository(worktree, gitdirectory string) (*Repository, error) {
-	var wt string
 	var err error
 	if worktree == "" {
-		wt, err = os.Getwd()
+		worktree, err = os.Getwd()
 		if err != nil {
 			return nil, err
 		}
-	} else {
-		wt = filepath.Clean(worktree)
 	}
-	var gd string
+	worktree = filepath.Clean(worktree)
 	if gitdirectory == "" {
-		gd, err = os.Getwd()
+		gitdirectory, err = os.Getwd()
 		if err != nil {
 			return nil, err
 		}
-		gd = gd + string(os.PathSeparator) + ".git"
-	} else {
-		gd = filepath.Clean(gitdirectory)
+		gitdirectory = filepath.Join(gitdirectory, ".git")
 	}
+	gitdirectory = filepath.Clean(gitdirectory)
 
 	r := &Repository{
-		WorkTree:     wt,
-		GitDirectory: gd,
+		WorkTree:     worktree,
+		GitDirectory: gitdirectory,
 	}
 	return r, nil
 }
diff --git a/internal/git/git_test.go b/internal/git/git_test.go
index 2a40e18..e530692 100644
--- a/internal/git/git_test.go
+++ b/internal/git/git_test.go
@@ -3,6 +3,7 @@ package git
 import (
 	"os"
 	"path"
+	"path/filepath"
 	"strings"
 	"testing"
 	"time"
@@ -12,7 +13,7 @@ import (
 
 func TestNewRepository(t *testing.T) {
 	cwd := currentWorkingDirectory(t)
-	cgd := cwd + string(os.PathSeparator) + ".git"
+	cgd := filepath.Join(cwd, ".git")
 
 	t.Run("defaults", func(t *testing.T) {
 		is := is.New(t)
@@ -165,7 +166,7 @@ func TestRepository_ChangelogWithDirectory(t *testing.T) {
 func TestRepository_run(t *testing.T) {
 	// current directory: . , ./.git
 	rootWT := currentWorkingDirectory(t)
-	rootGD := rootWT + string(os.PathSeparator) + ".git"
+	rootGD := filepath.Join(rootWT, ".git")
 
 	t.Run("current directory", func(t *testing.T) {
 		is := is.New(t)
@@ -295,6 +296,7 @@ func tempdir(tb testing.TB, cdToTempDir bool) string {
 	previous, err := os.Getwd()
 	is.NoErr(err)
 	dir := tb.TempDir()
+	tb.TempDir()
 	if cdToTempDir {
 		tb.Cleanup(func() {
 			is.NoErr(os.Chdir(previous))
diff --git a/internal/svu/svu.go b/internal/svu/svu.go
index 9b81b39..db4ba5b 100644
--- a/internal/svu/svu.go
+++ b/internal/svu/svu.go
@@ -37,12 +37,12 @@ type Options struct {
 	TagMode                   string
 	ForcePatchIncrement       bool
 	PreventMajorIncrementOnV0 bool
-	WorkTree                  string
+	GitWorkTree               string
 	GitDirectory              string
 }
 
 func Version(opts Options) (string, error) {
-	r, err := git.NewRepository(opts.WorkTree, opts.GitDirectory)
+	r, err := git.NewRepository(opts.GitWorkTree, opts.GitDirectory)
 	if err != nil {
 		return "", fmt.Errorf("failed finding the repository: %w", err)
 	}
diff --git a/main.go b/main.go
index d662a91..3cd519f 100644
--- a/main.go
+++ b/main.go
@@ -29,7 +29,7 @@ var (
 	tagMode   = app.Flag("tag-mode", "determines if latest tag of the current or all branches will be used").
 			Default("current-branch").
 			Enum("current-branch", "all-branches")
-	workTree = app.Flag("work-tree", "sets the git work-tree directory where the git repository exists").
+	gitWorkTree = app.Flag("git-work-tree", "sets the git work-tree directory where the git repository exists").
 			Default("").String()
 	gitDirectory        = app.Flag("git-directory", "sets the directory where the .git folder exists").Default("").String()
 	forcePatchIncrement = nextCmd.Flag("force-patch-increment", "forces a patch version increment regardless of the commit message content").
@@ -56,7 +56,7 @@ func main() {
 		Build:                     *build,
 		Directory:                 *directory,
 		TagMode:                   *tagMode,
-		WorkTree:                  *workTree,
+		GitWorkTree:               *gitWorkTree,
 		GitDirectory:              *gitDirectory,
 		ForcePatchIncrement:       *forcePatchIncrement,
 		PreventMajorIncrementOnV0: *preventMajorIncrementOnV0,
diff --git a/pkg/svu/svu.go b/pkg/svu/svu.go
index 8b0fdbb..3b40afe 100644
--- a/pkg/svu/svu.go
+++ b/pkg/svu/svu.go
@@ -102,9 +102,9 @@ func ForcePatchIncrement() option {
 	return WithForcePatchIncrement(true)
 }
 
-func WithWorkTree(directory string) option {
+func WithGitWorkTree(directory string) option {
 	return func(o *svu.Options) {
-		o.WorkTree = directory
+		o.GitWorkTree = directory
 	}
 }
 

From 57cc86637b88b46682719549790e14d32dd7a5c0 Mon Sep 17 00:00:00 2001
From: J <jimbo@Js-MacBook-Pro.local>
Date: Mon, 26 Aug 2024 16:25:50 -0400
Subject: [PATCH 4/4] refactor: more renaming

---
 internal/git/git.go      | 18 ++++++------
 internal/git/git_test.go | 60 ++++++++++++++++++++--------------------
 2 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/internal/git/git.go b/internal/git/git.go
index 3d5bdcd..db6812e 100644
--- a/internal/git/git.go
+++ b/internal/git/git.go
@@ -19,20 +19,20 @@ const (
 // copied from goreleaser
 
 type Repository struct {
-	WorkTree     string
+	GitWorkTree  string
 	GitDirectory string
 }
 
-// NewRepository creates a Repository. worktree and gitdirectory will default to 'pwd' and 'pwd/.git'
-func NewRepository(worktree, gitdirectory string) (*Repository, error) {
+// NewRepository creates a Repository. gitworktree and gitdirectory will default to 'pwd' and 'pwd/.git'
+func NewRepository(gitworktree, gitdirectory string) (*Repository, error) {
 	var err error
-	if worktree == "" {
-		worktree, err = os.Getwd()
+	if gitworktree == "" {
+		gitworktree, err = os.Getwd()
 		if err != nil {
 			return nil, err
 		}
 	}
-	worktree = filepath.Clean(worktree)
+	gitworktree = filepath.Clean(gitworktree)
 	if gitdirectory == "" {
 		gitdirectory, err = os.Getwd()
 		if err != nil {
@@ -43,7 +43,7 @@ func NewRepository(worktree, gitdirectory string) (*Repository, error) {
 	gitdirectory = filepath.Clean(gitdirectory)
 
 	r := &Repository{
-		WorkTree:     worktree,
+		GitWorkTree:  gitworktree,
 		GitDirectory: gitdirectory,
 	}
 	return r, nil
@@ -109,8 +109,8 @@ func (r *Repository) Changelog(tag string, dir string) (string, error) {
 
 func (r *Repository) run(args ...string) (string, error) {
 	extraArgs := []string{"-c", "log.showSignature=false"}
-	if r.WorkTree != "" {
-		extraArgs = append(extraArgs, fmt.Sprintf("--work-tree=%s", r.WorkTree))
+	if r.GitWorkTree != "" {
+		extraArgs = append(extraArgs, fmt.Sprintf("--work-tree=%s", r.GitWorkTree))
 	}
 	if r.GitDirectory != "" {
 		extraArgs = append(extraArgs, fmt.Sprintf("--git-dir=%s", r.GitDirectory))
diff --git a/internal/git/git_test.go b/internal/git/git_test.go
index e530692..e9d84ef 100644
--- a/internal/git/git_test.go
+++ b/internal/git/git_test.go
@@ -19,16 +19,16 @@ func TestNewRepository(t *testing.T) {
 		is := is.New(t)
 		r, err := NewRepository("", "")
 		is.NoErr(err)
-		is.Equal(r.WorkTree, cwd)
+		is.Equal(r.GitWorkTree, cwd)
 		is.Equal(r.GitDirectory, cgd)
 	})
 
-	t.Run("only worktree set", func(t *testing.T) {
-		wt := "/idk/some/work/tree/location"
+	t.Run("only gitworktree set", func(t *testing.T) {
+		gwt := "/idk/some/git/work/tree/location"
 		is := is.New(t)
-		r, err := NewRepository(wt, "")
+		r, err := NewRepository(gwt, "")
 		is.NoErr(err)
-		is.Equal(r.WorkTree, wt)
+		is.Equal(r.GitWorkTree, gwt)
 		is.Equal(r.GitDirectory, cgd)
 	})
 
@@ -37,15 +37,15 @@ func TestNewRepository(t *testing.T) {
 		is := is.New(t)
 		r, err := NewRepository("", gd)
 		is.NoErr(err)
-		is.Equal(r.WorkTree, cwd)
+		is.Equal(r.GitWorkTree, cwd)
 		is.Equal(r.GitDirectory, gd)
 	})
 
-	t.Run("worktree and gitdir set", func(t *testing.T) {
+	t.Run("gitworktree and gitdir set", func(t *testing.T) {
 		is := is.New(t)
 		r, err := NewRepository(cwd, cgd)
 		is.NoErr(err)
-		is.Equal(r.WorkTree, cwd)
+		is.Equal(r.GitWorkTree, cwd)
 		is.Equal(r.GitDirectory, cgd)
 	})
 }
@@ -165,22 +165,22 @@ func TestRepository_ChangelogWithDirectory(t *testing.T) {
 
 func TestRepository_run(t *testing.T) {
 	// current directory: . , ./.git
-	rootWT := currentWorkingDirectory(t)
-	rootGD := filepath.Join(rootWT, ".git")
+	rootGWT := currentWorkingDirectory(t)
+	rootGD := filepath.Join(rootGWT, ".git")
 
 	t.Run("current directory", func(t *testing.T) {
 		is := is.New(t)
 		rootRepository := Repository{
-			WorkTree:     rootWT,
+			GitWorkTree:  rootGWT,
 			GitDirectory: rootGD,
 		}
 		_, err := rootRepository.run("init")
 		is.NoErr(err)
 		is.True(rootRepository.IsRepo())
-		actualRootWT, err := rootRepository.run("rev-parse", "--show-toplevel")
+		actualRootGWT, err := rootRepository.run("rev-parse", "--show-toplevel")
 		is.NoErr(err)
-		actualRootWT = strings.TrimSuffix(actualRootWT, "\n") // git adds a new line to the cli output
-		is.Equal(actualRootWT, rootWT)
+		actualRootGWT = strings.TrimSuffix(actualRootGWT, "\n") // git adds a new line to the cli output
+		is.Equal(actualRootGWT, rootGWT)
 		actualGitDir, err := rootRepository.run("rev-parse", "--absolute-git-dir")
 		is.NoErr(err)
 		actualGitDir = strings.TrimSuffix(actualGitDir, "\n") // git adds a new line to the cli output
@@ -188,22 +188,22 @@ func TestRepository_run(t *testing.T) {
 	})
 
 	// subdirectory: ./foo , ./foo/.git
-	subWT := dir(currentWorkingDirectory(t), "foo", t)
-	subGD := dir(subWT, ".git", t)
+	subGWT := dir(currentWorkingDirectory(t), "foo", t)
+	subGD := dir(subGWT, ".git", t)
 
 	t.Run("subdirectory", func(t *testing.T) {
 		is := is.New(t)
 		subfolderRepository := Repository{
-			WorkTree:     subWT,
+			GitWorkTree:  subGWT,
 			GitDirectory: subGD,
 		}
 		_, err := subfolderRepository.run("init")
 		is.NoErr(err)
 		is.True(subfolderRepository.IsRepo())
-		actualWT, err := subfolderRepository.run("rev-parse", "--show-toplevel")
+		actualGWT, err := subfolderRepository.run("rev-parse", "--show-toplevel")
 		is.NoErr(err)
-		actualWT = strings.TrimSuffix(actualWT, "\n") // git adds a new line to the cli output
-		is.Equal(actualWT, subWT)
+		actualGWT = strings.TrimSuffix(actualGWT, "\n") // git adds a new line to the cli output
+		is.Equal(actualGWT, subGWT)
 		actualGitDir, err := subfolderRepository.run("rev-parse", "--absolute-git-dir")
 		is.NoErr(err)
 		actualGitDir = strings.TrimSuffix(actualGitDir, "\n") // git adds a new line to the cli output
@@ -211,11 +211,11 @@ func TestRepository_run(t *testing.T) {
 	})
 
 	// external: /temp/sdfjklds , /temp/sdfjklds/.git
-	externalWT := tempdir(t, false)
-	externalGD := dir(externalWT, ".git", t)
-	tmpWTFileName := "somefile.txt"
-	tmpWTFilePath := tempfile(t, externalWT, tmpWTFileName)
-	expectedWTContent, _ := dataFromFile(tmpWTFilePath)
+	externalGWT := tempdir(t, false)
+	externalGD := dir(externalGWT, ".git", t)
+	tmpGWTFileName := "somefile.txt"
+	tmpGWTFilePath := tempfile(t, externalGWT, tmpGWTFileName)
+	expectedGWTContent, _ := dataFromFile(tmpGWTFilePath)
 	tmpGDFileName := "somefile.txt"
 	tmpGDFilePath := tempfile(t, externalGD, tmpGDFileName)
 	expectedGDContent, _ := dataFromFile(tmpGDFilePath)
@@ -223,19 +223,19 @@ func TestRepository_run(t *testing.T) {
 	t.Run("external directory", func(t *testing.T) {
 		is := is.New(t)
 		externalRepository := Repository{
-			WorkTree:     externalWT,
+			GitWorkTree:  externalGWT,
 			GitDirectory: externalGD,
 		}
 		_, err := externalRepository.run("init")
 		is.NoErr(err)
 		is.True(externalRepository.IsRepo())
-		actualWT, err := externalRepository.run("rev-parse", "--show-toplevel")
+		actualGWT, err := externalRepository.run("rev-parse", "--show-toplevel")
 		is.NoErr(err)
-		actualWT = strings.TrimSuffix(actualWT, "\n") // git adds a new line to the cli output
+		actualGWT = strings.TrimSuffix(actualGWT, "\n") // git adds a new line to the cli output
 		// compare file content instead of having to deal with symlink paths
-		actualWTContent, err := dataFromFile(actualWT + string(os.PathSeparator) + tmpWTFileName)
+		actualWTContent, err := dataFromFile(actualGWT + string(os.PathSeparator) + tmpGWTFileName)
 		is.NoErr(err)
-		is.Equal(expectedWTContent, actualWTContent)
+		is.Equal(expectedGWTContent, actualWTContent)
 
 		actualGD, err := externalRepository.run("rev-parse", "--absolute-git-dir")
 		is.NoErr(err)