Refactor repo_paths.go to use git rev-parse

This changes GetRepoPaths() to pull information from `git rev-parse`
instead of effectively reimplementing git's logic for pathfinding. This
change fixes issues with bare repos, esp. versioned homedir use cases,
by aligning lazygit's path handling to what git itself does.

This change also enables lazygit to run from arbitrary subdirectories of
a repository, including correct handling of symlinks, including "deep"
symlinks into a repo, worktree, a repo's submodules, etc.

Integration tests are now resilient against unintended side effects from
the host's environment variables. Of necessity, $PATH and $TERM are the
only env vars allowed through now.

1 files changed, 46 insertions, 151 deletions

diff --git a/pkg/commands/git_commands/repo_paths.go b/pkg/commands/git_commands/repo_paths.go
index 13cda86a4..b0e1970db 100644
--- a/pkg/commands/git_commands/repo_paths.go
+++ b/pkg/commands/git_commands/repo_paths.go
@@ -1,21 +1,18 @@
 package git_commands
 
 import (
-	"fmt"
 	ioFs "io/fs"
-	"os"
 	"path"
 	"path/filepath"
 	"strings"
 
 	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/env"
-	"github.com/samber/lo"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/utils"
 	"github.com/spf13/afero"
 )
 
 type RepoPaths struct {
-	currentPath        string
 	worktreePath       string
 	worktreeGitDirPath string
 	repoPath           string
@@ -23,12 +20,7 @@ type RepoPaths struct {
 	repoName           string
 }
 
-// Current working directory of the program. Currently, this will always
-// be the same as WorktreePath(), but in future we may support running
-// lazygit from inside a subdirectory of the worktree.
-func (self *RepoPaths) CurrentPath() string {
-	return self.currentPath
-}
+var gitPathFormatVersion GitVersion = GitVersion{2, 31, 0, ""}
 
 // Path to the current worktree. If we're in the main worktree, this will
 // be the same as RepoPath()
@@ -65,7 +57,6 @@ func (self *RepoPaths) RepoName() string {
 // Returns the repo paths for a typical repo
 func MockRepoPaths(currentPath string) *RepoPaths {
 	return &RepoPaths{
-		currentPath:        currentPath,
 		worktreePath:       currentPath,
 		worktreeGitDirPath: path.Join(currentPath, ".git"),
 		repoPath:           currentPath,
@@ -75,44 +66,41 @@ func MockRepoPaths(currentPath string) *RepoPaths {
 }
 
 func GetRepoPaths(
-	fs afero.Fs,
-	currentPath string,
-) (*RepoPaths, error) {
-	return getRepoPathsAux(afero.NewOsFs(), resolveSymlink, currentPath)
-}
-
-func getRepoPathsAux(
-	fs afero.Fs,
-	resolveSymlinkFn func(string) (string, error),
-	currentPath string,
+	cmd oscommands.ICmdObjBuilder,
+	version *GitVersion,
 ) (*RepoPaths, error) {
-	worktreePath := currentPath
-	repoGitDirPath, repoPath, err := getCurrentRepoGitDirPath(fs, resolveSymlinkFn, currentPath)
+	gitDirOutput, err := callGitRevParse(cmd, version, "--show-toplevel", "--absolute-git-dir", "--git-common-dir", "--show-superproject-working-tree")
 	if err != nil {
-		return nil, errors.Errorf("failed to get repo git dir path: %v", err)
+		return nil, err
 	}
 
-	var worktreeGitDirPath string
-	if env.GetWorkTreeEnv() != "" {
-		// This env is set when you pass --work-tree to lazygit. In that case,
-		// we're not dealing with a linked work-tree, we're dealing with a 'specified'
-		// worktree (for lack of a better term). In this case, the worktree has no
-		// .git file and it just contains a bunch of files: it has no idea it's
-		// pointed to by a bare repo. As such it does not have its own git dir within
-		// the bare repo's git dir. Instead, we just use the bare repo's git dir.
-		worktreeGitDirPath = repoGitDirPath
-	} else {
-		var err error
-		worktreeGitDirPath, err = getWorktreeGitDirPath(fs, currentPath)
+	gitDirResults := strings.Split(utils.NormalizeLinefeeds(gitDirOutput), "\n")
+	worktreePath := gitDirResults[0]
+	worktreeGitDirPath := gitDirResults[1]
+	repoGitDirPath := gitDirResults[2]
+	if version.IsOlderThanVersion(&gitPathFormatVersion) {
+		repoGitDirPath, err = filepath.Abs(repoGitDirPath)
 		if err != nil {
-			return nil, errors.Errorf("failed to get worktree git dir path: %v", err)
+			return nil, err
 		}
 	}
 
+	// If we're in a submodule, --show-superproject-working-tree will return
+	// a value, meaning gitDirResults will be length 4. In that case
+	// return the worktree path as the repoPath. Otherwise we're in a
+	// normal repo or a worktree so return the parent of the git common
+	// dir (repoGitDirPath)
+	isSubmodule := len(gitDirResults) == 4
+
+	var repoPath string
+	if isSubmodule {
+		repoPath = worktreePath
+	} else {
+		repoPath = path.Dir(repoGitDirPath)
+	}
 	repoName := path.Base(repoPath)
 
 	return &RepoPaths{
-		currentPath:        currentPath,
 		worktreePath:       worktreePath,
 		worktreeGitDirPath: worktreeGitDirPath,
 		repoPath:           repoPath,
@@ -121,124 +109,31 @@ func getRepoPathsAux(
 	}, nil
 }
 
-// Returns the path of the git-dir for the worktree. For linked worktrees, the worktree has
-// a .git file that points to the git-dir (which itself lives in the git-dir
-// of the repo)
-func getWorktreeGitDirPath(fs afero.Fs, worktreePath string) (string, error) {
-	// if .git is a file, we're in a linked worktree, otherwise we're in
-	// the main worktree
-	dotGitPath := path.Join(worktreePath, ".git")
-	gitFileInfo, err := fs.Stat(dotGitPath)
-	if err != nil {
-		return "", err
-	}
-
-	if gitFileInfo.IsDir() {
-		return dotGitPath, nil
-	}
-
-	return linkedWorktreeGitDirPath(fs, worktreePath)
+func callGitRevParse(
+	cmd oscommands.ICmdObjBuilder,
+	version *GitVersion,
+	gitRevArgs ...string,
+) (string, error) {
+	return callGitRevParseWithDir(cmd, version, "", gitRevArgs...)
 }
 
-func linkedWorktreeGitDirPath(fs afero.Fs, worktreePath string) (string, error) {
-	dotGitPath := path.Join(worktreePath, ".git")
-	gitFileContents, err := afero.ReadFile(fs, dotGitPath)
-	if err != nil {
-		return "", err
-	}
-
-	// The file will have `gitdir: /path/to/.git/worktrees/<worktree-name>`
-	gitDirLine := lo.Filter(strings.Split(string(gitFileContents), "\n"), func(line string, _ int) bool {
-		return strings.HasPrefix(line, "gitdir: ")
-	})
-
-	if len(gitDirLine) == 0 {
-		return "", errors.New(fmt.Sprintf("%s is a file which suggests we are in a submodule or a worktree but the file's contents do not contain a gitdir pointing to the actual .git directory", dotGitPath))
-	}
-
-	gitDir := strings.TrimPrefix(gitDirLine[0], "gitdir: ")
-
-	gitDir = filepath.Clean(gitDir)
-	// For windows support
-	gitDir = filepath.ToSlash(gitDir)
-
-	return gitDir, nil
-}
-
-func getCurrentRepoGitDirPath(
-	fs afero.Fs,
-	resolveSymlinkFn func(string) (string, error),
-	currentPath string,
-) (string, string, error) {
-	var unresolvedGitPath string
-	if env.GetGitDirEnv() != "" {
-		unresolvedGitPath = env.GetGitDirEnv()
-	} else {
-		unresolvedGitPath = path.Join(currentPath, ".git")
+func callGitRevParseWithDir(
+	cmd oscommands.ICmdObjBuilder,
+	version *GitVersion,
+	dir string,
+	gitRevArgs ...string,
+) (string, error) {
+	gitRevParse := NewGitCmd("rev-parse").ArgIf(version.IsAtLeastVersion(&gitPathFormatVersion), "--path-format=absolute").Arg(gitRevArgs...)
+	if dir != "" {
+		gitRevParse.Dir(dir)
 	}
 
-	gitPath, err := resolveSymlinkFn(unresolvedGitPath)
+	gitCmd := cmd.New(gitRevParse.ToArgv()).DontLog()
+	res, err := gitCmd.RunWithOutput()
 	if err != nil {
-		return "", "", err
+		return "", errors.Errorf("'%s' failed: %v", gitCmd.ToString(), err)
 	}
-
-	// check if .git is a file or a directory
-	gitFileInfo, err := fs.Stat(gitPath)
-	if err != nil {
-		return "", "", err
-	}
-
-	if gitFileInfo.IsDir() {
-		// must be in the main worktree
-		return gitPath, path.Dir(gitPath), nil
-	}
-
-	// either in a submodule, or worktree
-	worktreeGitPath, err := linkedWorktreeGitDirPath(fs, currentPath)
-	if err != nil {
-		return "", "", errors.Errorf("could not find git dir for %s: %v", currentPath, err)
-	}
-
-	_, err = fs.Stat(worktreeGitPath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			// hardcoding error to get around windows-specific error message
-			return "", "", errors.Errorf("could not find git dir for %s. %s does not exist", currentPath, worktreeGitPath)
-		}
-		return "", "", errors.Errorf("could not find git dir for %s: %v", currentPath, err)
-	}
-
-	// confirm whether the next directory up is the worktrees directory
-	parent := path.Dir(worktreeGitPath)
-	if path.Base(parent) == "worktrees" {
-		gitDirPath := path.Dir(parent)
-		return gitDirPath, path.Dir(gitDirPath), nil
-	}
-
-	// Unlike worktrees, submodules can be nested arbitrarily deep, so we check
-	// if the `modules` directory is anywhere up the chain.
-	if strings.Contains(worktreeGitPath, "/modules/") {
-		// For submodules, we just return the path directly
-		return worktreeGitPath, currentPath, nil
-	}
-
-	// If this error causes issues, we could relax the constraint and just always
-	// return the path
-	return "", "", errors.Errorf("could not find git dir for %s: the path '%s' is not under `worktrees` or `modules` directories", currentPath, worktreeGitPath)
-}
-
-// takes a path containing a symlink and returns the true path
-func resolveSymlink(path string) (string, error) {
-	l, err := os.Lstat(path)
-	if err != nil {
-		return "", err
-	}
-
-	if l.Mode()&os.ModeSymlink == 0 {
-		return path, nil
-	}
-
-	return filepath.EvalSymlinks(path)
+	return strings.TrimSpace(res), nil
 }
 
 // Returns the paths of linked worktrees