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.

.editorconfig

@@ -0,0 +1,4 @@
+root = true
+
+[*.go]
+indent_style = tab

pkg/commands/git.go

@@ -2,20 +2,16 @@ package commands
 
 import (
 	"os"
-	"path"
-	"path/filepath"
 	"strings"
 
 	"github.com/go-errors/errors"
-	"github.com/spf13/afero"
 
 	gogit "github.com/jesseduffield/go-git/v5"
 	"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
 	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
 	"github.com/jesseduffield/lazygit/pkg/commands/patch"
 	"github.com/jesseduffield/lazygit/pkg/common"
-	"github.com/jesseduffield/lazygit/pkg/env"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
@@ -64,39 +60,14 @@ func NewGitCommand(
 	osCommand *oscommands.OSCommand,
 	gitConfig git_config.IGitConfig,
 ) (*GitCommand, error) {
-	currentPath, err := os.Getwd()
+	repoPaths, err := git_commands.GetRepoPaths(osCommand.Cmd, version)
 	if err != nil {
-		return nil, utils.WrapError(err)
-	}
-
-	// converting to forward slashes for the sake of windows (which uses backwards slashes). We want everything
-	// to have forward slashes internally
-	currentPath = filepath.ToSlash(currentPath)
-
-	gitDir := env.GetGitDirEnv()
-	if gitDir != "" {
-		// we've been given the git directory explicitly so no need to navigate to it
-		_, err := cmn.Fs.Stat(gitDir)
-		if err != nil {
-			return nil, utils.WrapError(err)
-		}
-	} else {
-		// we haven't been given the git dir explicitly so we assume it's in the current working directory as `.git/` (or an ancestor directory)
-
-		rootDirectory, err := findWorktreeRoot(cmn.Fs, currentPath)
-		if err != nil {
-			return nil, utils.WrapError(err)
-		}
-		currentPath = rootDirectory
-		err = os.Chdir(rootDirectory)
-		if err != nil {
-			return nil, utils.WrapError(err)
-		}
+		return nil, errors.Errorf("Error getting repo paths: %v", err)
 	}
 
-	repoPaths, err := git_commands.GetRepoPaths(cmn.Fs, currentPath)
+	err = os.Chdir(repoPaths.WorktreePath())
 	if err != nil {
-		return nil, errors.Errorf("Error getting repo paths: %v", err)
+		return nil, utils.WrapError(err)
 	}
 
 	repository, err := gogit.PlainOpenWithOptions(
@@ -208,32 +179,6 @@ func NewGitCommandAux(
 	}
 }
 
-// this returns the root of the current worktree. So if you start lazygit from within
-// a subdirectory of the worktree, it will start in the context of the root of that worktree
-func findWorktreeRoot(fs afero.Fs, currentPath string) (string, error) {
-	for {
-		// we don't care if .git is a directory or a file: either is okay.
-		_, err := fs.Stat(path.Join(currentPath, ".git"))
-
-		if err == nil {
-			return currentPath, nil
-		}
-
-		if !os.IsNotExist(err) {
-			return "", utils.WrapError(err)
-		}
-
-		currentPath = path.Dir(currentPath)
-
-		atRoot := currentPath == path.Dir(currentPath)
-		if atRoot {
-			// we should never really land here: the code that creates GitCommand should
-			// verify we're in a git directory
-			return "", errors.New("Must open lazygit in a git repository")
-		}
-	}
-}
-
 func VerifyInGitRepo(osCommand *oscommands.OSCommand) error {
 	return osCommand.Cmd.New(git_commands.NewGitCmd("rev-parse").Arg("--git-dir").ToArgv()).DontLog().Run()
 }

pkg/commands/git_commands/commit.go

@@ -250,6 +250,7 @@ func (self *CommitCommands) ShowCmdObj(sha string, filterPath string) oscommands
 		Arg(sha).
 		ArgIf(self.AppState.IgnoreWhitespaceInDiffView, "--ignore-all-space").
 		ArgIf(filterPath != "", "--", filterPath).
+		Dir(self.repoPaths.worktreePath).
 		ToArgv()
 
 	return self.cmd.New(cmdArgs).DontLog()

pkg/commands/git_commands/commit_test.go

@@ -197,39 +197,39 @@ func TestCommitShowCmdObj(t *testing.T) {
 			contextSize:      3,
 			ignoreWhitespace: false,
 			extDiffCmd:       "",
-			expected:         []string{"show", "--no-ext-diff", "--submodule", "--color=always", "--unified=3", "--stat", "--decorate", "-p", "1234567890"},
+			expected:         []string{"-C", "/path/to/worktree", "show", "--no-ext-diff", "--submodule", "--color=always", "--unified=3", "--stat", "--decorate", "-p", "1234567890"},
 		},
 		{
 			testName:         "Default case with filter path",
 			filterPath:       "file.txt",
 			contextSize:      3,
 			ignoreWhitespace: false,
 			extDiffCmd:       "",
-			expected:         []string{"show", "--no-ext-diff", "--submodule", "--color=always", "--unified=3", "--stat", "--decorate", "-p", "1234567890", "--", "file.txt"},
+			expected:         []string{"-C", "/path/to/worktree", "show", "--no-ext-diff", "--submodule", "--color=always", "--unified=3", "--stat", "--decorate", "-p", "1234567890", "--", "file.txt"},
 		},
 		{
 			testName:         "Show diff with custom context size",
 			filterPath:       "",
 			contextSize:      77,
 			ignoreWhitespace: false,
 			extDiffCmd:       "",
-			expected:         []string{"show", "--no-ext-diff", "--submodule", "--color=always", "--unified=77", "--stat", "--decorate", "-p", "1234567890"},
+			expected:         []string{"-C", "/path/to/worktree", "show", "--no-ext-diff", "--submodule", "--color=always", "--unified=77", "--stat", "--decorate", "-p", "1234567890"},
 		},
 		{
 			testName:         "Show diff, ignoring whitespace",
 			filterPath:       "",
 			contextSize:      77,
 			ignoreWhitespace: true,
 			extDiffCmd:       "",
-			expected:         []string{"show", "--no-ext-diff", "--submodule", "--color=always", "--unified=77", "--stat", "--decorate", "-p", "1234567890", "--ignore-all-space"},
+			expected:         []string{"-C", "/path/to/worktree", "show", "--no-ext-diff", "--submodule", "--color=always", "--unified=77", "--stat", "--decorate", "-p", "1234567890", "--ignore-all-space"},
 		},
 		{
 			testName:         "Show diff with external diff command",
 			filterPath:       "",
 			contextSize:      3,
 			ignoreWhitespace: false,
 			extDiffCmd:       "difft --color=always",
-			expected:         []string{"-c", "diff.external=difft --color=always", "show", "--ext-diff", "--submodule", "--color=always", "--unified=3", "--stat", "--decorate", "-p", "1234567890"},
+			expected:         []string{"-C", "/path/to/worktree", "-c", "diff.external=difft --color=always", "show", "--ext-diff", "--submodule", "--color=always", "--unified=3", "--stat", "--decorate", "-p", "1234567890"},
 		},
 	}
 
@@ -243,7 +243,10 @@ func TestCommitShowCmdObj(t *testing.T) {
 			appState.DiffContextSize = s.contextSize
 
 			runner := oscommands.NewFakeRunner(t).ExpectGitArgs(s.expected, "", nil)
-			instance := buildCommitCommands(commonDeps{userConfig: userConfig, appState: appState, runner: runner})
+			repoPaths := RepoPaths{
+				worktreePath: "/path/to/worktree",
+			}
+			instance := buildCommitCommands(commonDeps{userConfig: userConfig, appState: appState, runner: runner, repoPaths: &repoPaths})
 
 			assert.NoError(t, instance.ShowCmdObj("1234567890", s.filterPath).Run())
 			runner.CheckForMissingCalls()

pkg/commands/git_commands/diff.go

@@ -14,14 +14,19 @@ func NewDiffCommands(gitCommon *GitCommon) *DiffCommands {
 
 func (self *DiffCommands) DiffCmdObj(diffArgs []string) oscommands.ICmdObj {
 	return self.cmd.New(
-		NewGitCmd("diff").Arg("--submodule", "--no-ext-diff", "--color").Arg(diffArgs...).ToArgv(),
+		NewGitCmd("diff").
+			Arg("--submodule", "--no-ext-diff", "--color").
+			Arg(diffArgs...).
+			Dir(self.repoPaths.worktreePath).
+			ToArgv(),
 	)
 }
 
 func (self *DiffCommands) internalDiffCmdObj(diffArgs ...string) *GitCommandBuilder {
 	return NewGitCmd("diff").
 		Arg("--no-ext-diff", "--no-color").
-		Arg(diffArgs...)
+		Arg(diffArgs...).
+		Dir(self.repoPaths.worktreePath)
 }
 
 func (self *DiffCommands) GetPathDiff(path string, staged bool) (string, error) {