mirror of
https://github.com/jesseduffield/lazygit.git
synced 2026-08-24 10:13:41 -05:00
Stefan HallerandClaude Opus 5
d19af37ee7
git finds a repo by looking for a .git in the directory a command runs
in. Lazygit runs its commands in the work tree, so that normally works —
but not when the git dir lives somewhere else entirely, which is what
core.worktree and --work-tree are for. Lazygit chdir'd into such a work
tree and then ran commands that couldn't see any repo from there, so
opening a repo with core.worktree set panicked on startup. It only
worked with --git-dir because that leaves GIT_DIR in the environment for
every command to inherit.
Work out at startup whether git can find the repo from its work tree,
and when it can't, put GIT_DIR and GIT_WORK_TREE on every command the
repo's builder produces. As with the working directory the builder pins
(527124d0e0), these also go into the process env — subprocesses don't
come through the builder — but the commands don't read them from there,
because the process env belongs to whichever repo we have switched to
since.
Working out whether git can find the repo means asking git, rather than
reading the .git file, whose contents can spell the same directory
differently than git does. The extra query is skipped for a repo whose
git dir is simply its .git directory, which is nearly all of them.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
68 lines
3.2 KiB
Go
68 lines
3.2 KiB
Go
package commands
|
|
|
|
import (
|
|
"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
|
|
"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// all we're doing here is wrapping the default command object builder with
|
|
// some git-specific stuff: e.g. adding a git-specific env var
|
|
|
|
type gitCmdObjBuilder struct {
|
|
innerBuilder *oscommands.CmdObjBuilder
|
|
|
|
// The directory of the repo (or worktree) this builder was created for;
|
|
// every command we produce runs there, regardless of the process's current
|
|
// working directory. The two are the same until the user switches to
|
|
// another repo: lazygit chdirs on a switch, but work still in flight for
|
|
// the previous repo (e.g. a background refresh spawning commands through
|
|
// the old builder) must keep running its commands against the repo it
|
|
// started in, not whichever one the process has since moved to.
|
|
repoDir string
|
|
|
|
// The env vars every command we produce gets: the optional-locks one below,
|
|
// plus the repo's git location if it has one (see
|
|
// RepoPaths.GitLocationEnvVars). Those are in the process env too, but for
|
|
// the same reason as repoDir we don't rely on that: the process env belongs
|
|
// to whichever repo lazygit has since switched to.
|
|
envVars []string
|
|
}
|
|
|
|
var _ oscommands.ICmdObjBuilder = &gitCmdObjBuilder{}
|
|
|
|
// We disable git's optional locks on every command by default so that our git
|
|
// invocations never contend for index.lock. See git_commands.OptionalLocksEnvVar
|
|
// for the full rationale. Individual commands that do want the lock (currently
|
|
// only the foreground files refresh) opt back in via CmdObj.RemoveEnvVar.
|
|
var defaultEnvVar = git_commands.OptionalLocksEnvVar + "=0"
|
|
|
|
func NewGitCmdObjBuilder(log *logrus.Entry, innerBuilder *oscommands.CmdObjBuilder, repoDir string, gitLocationEnvVars []string) *gitCmdObjBuilder {
|
|
// the price of having a convenient interface where we can say .New(...).Run() is that our builder now depends on our runner, so when we want to wrap the default builder/runner in new functionality we need to jump through some hoops. We could avoid the use of a decorator function here by just exporting the runner field on the default builder but that would be misleading because we don't want anybody using that to run commands (i.e. we want there to be a single API used across the codebase)
|
|
updatedBuilder := innerBuilder.CloneWithNewRunner(func(runner oscommands.ICmdObjRunner) oscommands.ICmdObjRunner {
|
|
return &gitCmdObjRunner{
|
|
log: log,
|
|
innerRunner: runner,
|
|
initialRetryDelay: defaultInitialRetryDelay,
|
|
}
|
|
})
|
|
|
|
return &gitCmdObjBuilder{
|
|
innerBuilder: updatedBuilder,
|
|
repoDir: repoDir,
|
|
envVars: append([]string{defaultEnvVar}, gitLocationEnvVars...),
|
|
}
|
|
}
|
|
|
|
func (self *gitCmdObjBuilder) New(args []string) *oscommands.CmdObj {
|
|
return self.innerBuilder.New(args).AddEnvVars(self.envVars...).SetWd(self.repoDir)
|
|
}
|
|
|
|
func (self *gitCmdObjBuilder) NewShell(cmdStr string, shellFunctionsFile string) *oscommands.CmdObj {
|
|
return self.innerBuilder.NewShell(cmdStr, shellFunctionsFile).AddEnvVars(self.envVars...).SetWd(self.repoDir)
|
|
}
|
|
|
|
func (self *gitCmdObjBuilder) Quote(str string) string {
|
|
return self.innerBuilder.Quote(str)
|
|
}
|