mirror of
https://github.com/jesseduffield/lazygit.git
synced 2026-11-21 04:46:29 +03:00
The commits view marks the commits that a bisect hasn't ruled out yet with a "?". To find them, it looks for the bad commit and the first good commit in the list, and marks the commits between them. If there's no good commit in the list, it marks none. This is the case while git tests the merge base of a good and a bad commit on different branches. It's also the case early in a long bisect, when the good commit is further down than the commits that we load. With merges, the commits between the two can also include some that the bisect has ruled out. Ask git instead, with "git rev-list <bad> --not <good>...", when refreshing the commits while git knows both a good and a bad commit. This takes about as long as the git log that loads the commits, or less, and it gets faster as the bisect goes on. Keep only the commits that the commits view has loaded, because git may list many more. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
251 lines
6.8 KiB
Go
251 lines
6.8 KiB
Go
package git_commands
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/jesseduffield/generics/set"
|
|
"github.com/jesseduffield/lazygit/pkg/commands/models"
|
|
"github.com/samber/lo"
|
|
)
|
|
|
|
type BisectCommands struct {
|
|
*GitCommon
|
|
}
|
|
|
|
func NewBisectCommands(gitCommon *GitCommon) *BisectCommands {
|
|
return &BisectCommands{
|
|
GitCommon: gitCommon,
|
|
}
|
|
}
|
|
|
|
// This command is pretty cheap to run so we're not storing the result anywhere.
|
|
// But if it becomes problematic we can chang that.
|
|
func (self *BisectCommands) GetInfo() *BisectInfo {
|
|
return self.GetInfoForGitDir(self.repoPaths.WorktreeGitDirPath())
|
|
}
|
|
|
|
func (self *BisectCommands) GetInfoForGitDir(gitDir string) *BisectInfo {
|
|
var err error
|
|
info := &BisectInfo{started: false, log: self.Log, newTerm: "bad", oldTerm: "good"}
|
|
// we return nil if we're not in a git bisect session.
|
|
// we know we're in a session by the presence of a .git/BISECT_START file
|
|
|
|
bisectStartPath := filepath.Join(gitDir, "BISECT_START")
|
|
exists, err := self.os.FileExists(bisectStartPath)
|
|
if err != nil {
|
|
self.Log.Infof("error getting git bisect info: %s", err.Error())
|
|
return info
|
|
}
|
|
|
|
if !exists {
|
|
return info
|
|
}
|
|
|
|
startContent, err := os.ReadFile(bisectStartPath)
|
|
if err != nil {
|
|
self.Log.Infof("error getting git bisect info: %s", err.Error())
|
|
return info
|
|
}
|
|
|
|
info.started = true
|
|
info.start = strings.TrimSpace(string(startContent))
|
|
|
|
termsContent, err := os.ReadFile(filepath.Join(gitDir, "BISECT_TERMS"))
|
|
if err != nil {
|
|
// old git versions won't have this file so we default to bad/good
|
|
} else {
|
|
splitContent := strings.Split(string(termsContent), "\n")
|
|
info.newTerm = splitContent[0]
|
|
info.oldTerm = splitContent[1]
|
|
}
|
|
|
|
bisectRefsDir := filepath.Join(gitDir, "refs", "bisect")
|
|
files, err := os.ReadDir(bisectRefsDir)
|
|
if err != nil {
|
|
self.Log.Infof("error getting git bisect info: %s", err.Error())
|
|
return info
|
|
}
|
|
|
|
info.statusMap = make(map[string]BisectStatus)
|
|
for _, file := range files {
|
|
status := BisectStatusSkipped
|
|
name := file.Name()
|
|
path := filepath.Join(bisectRefsDir, name)
|
|
|
|
fileContent, err := os.ReadFile(path)
|
|
if err != nil {
|
|
self.Log.Infof("error getting git bisect info: %s", err.Error())
|
|
return info
|
|
}
|
|
|
|
hash := strings.TrimSpace(string(fileContent))
|
|
|
|
if name == info.newTerm {
|
|
status = BisectStatusNew
|
|
} else if strings.HasPrefix(name, info.oldTerm+"-") {
|
|
status = BisectStatusOld
|
|
} else if strings.HasPrefix(name, "skipped-") {
|
|
status = BisectStatusSkipped
|
|
}
|
|
|
|
info.statusMap[hash] = status
|
|
}
|
|
|
|
currentContent, err := os.ReadFile(filepath.Join(gitDir, "BISECT_EXPECTED_REV"))
|
|
if err != nil {
|
|
self.Log.Infof("error getting git bisect info: %s", err.Error())
|
|
return info
|
|
}
|
|
currentHash := strings.TrimSpace(string(currentContent))
|
|
info.current = currentHash
|
|
|
|
return info
|
|
}
|
|
|
|
func (self *BisectCommands) Reset() error {
|
|
cmdArgs := NewGitCmd("bisect").Arg("reset").ToArgv()
|
|
|
|
return self.cmd.New(cmdArgs).StreamOutput().Run()
|
|
}
|
|
|
|
func (self *BisectCommands) Mark(ref string, term string) error {
|
|
cmdArgs := NewGitCmd("bisect").Arg(term, ref).ToArgv()
|
|
|
|
return self.cmd.New(cmdArgs).
|
|
IgnoreEmptyError().
|
|
StreamOutput().
|
|
Run()
|
|
}
|
|
|
|
func (self *BisectCommands) Skip(ref string) error {
|
|
return self.Mark(ref, "skip")
|
|
}
|
|
|
|
func (self *BisectCommands) Start() error {
|
|
cmdArgs := NewGitCmd("bisect").Arg("start").ToArgv()
|
|
|
|
return self.cmd.New(cmdArgs).StreamOutput().Run()
|
|
}
|
|
|
|
func (self *BisectCommands) StartWithTerms(oldTerm string, newTerm string) error {
|
|
cmdArgs := NewGitCmd("bisect").Arg("start").
|
|
Arg("--term-old=" + oldTerm).
|
|
Arg("--term-new=" + newTerm).
|
|
ToArgv()
|
|
|
|
return self.cmd.New(cmdArgs).StreamOutput().Run()
|
|
}
|
|
|
|
// tells us whether we've found our problem commit(s). We return a string slice of
|
|
// commit hashes if we're done, and that slice may have more that one item if
|
|
// skipped commits are involved.
|
|
func (self *BisectCommands) IsDone() (bool, []string, error) {
|
|
info := self.GetInfo()
|
|
if !info.Bisecting() {
|
|
return false, nil, nil
|
|
}
|
|
|
|
newHash := info.GetNewHash()
|
|
if newHash == "" {
|
|
return false, nil, nil
|
|
}
|
|
|
|
// if we start from the new commit and reach the a good commit without
|
|
// coming across any unprocessed commits, then we're done
|
|
done := false
|
|
candidates := []string{}
|
|
|
|
cmdArgs := NewGitCmd("rev-list").Arg(newHash).ToArgv()
|
|
err := self.cmd.New(cmdArgs).DontLog().RunAndProcessLines(func(line string) (bool, error) {
|
|
hash := strings.TrimSpace(line)
|
|
|
|
if status, ok := info.statusMap[hash]; ok {
|
|
switch status {
|
|
case BisectStatusSkipped, BisectStatusNew:
|
|
candidates = append(candidates, hash)
|
|
return false, nil
|
|
case BisectStatusOld:
|
|
done = true
|
|
return true, nil
|
|
}
|
|
} else {
|
|
return true, nil
|
|
}
|
|
|
|
// should never land here
|
|
return true, nil
|
|
})
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
|
|
return done, candidates, nil
|
|
}
|
|
|
|
// Asks git which of the given commits the bisect hasn't ruled out yet, and
|
|
// stores them in the bisect info. Git may list many more commits than these,
|
|
// so we don't keep the others.
|
|
func (self *BisectCommands) LoadCandidates(info *BisectInfo, commits []*models.Commit) error {
|
|
if !info.Bisecting() {
|
|
return nil
|
|
}
|
|
|
|
oldHashes := lo.Keys(lo.PickBy(info.statusMap, func(_ string, status BisectStatus) bool {
|
|
return status == BisectStatusOld
|
|
}))
|
|
cmdArgs := NewGitCmd("rev-list").
|
|
Arg(info.GetNewHash(), "--not").
|
|
Arg(oldHashes...).
|
|
ToArgv()
|
|
|
|
loadedHashes := set.NewFromSlice(lo.Map(commits, func(commit *models.Commit, _ int) string {
|
|
return commit.Hash()
|
|
}))
|
|
candidates := set.New[string]()
|
|
err := self.cmd.New(cmdArgs).DontLog().RunAndProcessLines(func(line string) (bool, error) {
|
|
if hash := strings.TrimSpace(line); loadedHashes.Includes(hash) {
|
|
candidates.Add(hash)
|
|
}
|
|
return false, nil
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
info.candidates = candidates
|
|
return nil
|
|
}
|
|
|
|
// tells us whether the 'start' ref that we'll be sent back to after we're done
|
|
// bisecting is actually a descendant of our current bisect commit. If it's not, we need to
|
|
// render the commits from the bad commit.
|
|
func (self *BisectCommands) ReachableFromStart(bisectInfo *BisectInfo) bool {
|
|
cmdArgs := NewGitCmd("merge-base").
|
|
Arg("--is-ancestor", bisectInfo.GetNewHash(), bisectInfo.GetStartHash()).
|
|
ToArgv()
|
|
|
|
err := self.cmd.New(cmdArgs).DontLog().Run()
|
|
|
|
return err == nil
|
|
}
|
|
|
|
// Returns the number of commits that are reachable from logRef but not from
|
|
// the given commit. In a log of logRef, parents come after their children
|
|
// (unless the log uses git's default order and commit dates are skewed), so
|
|
// the commit is at most this many commits down from the top.
|
|
func (self *BisectCommands) CountCommitsAbove(hash string, logRef string) (int, error) {
|
|
cmdArgs := NewGitCmd("rev-list").
|
|
Arg("--count", hash+".."+logRef).
|
|
ToArgv()
|
|
|
|
output, err := self.cmd.New(cmdArgs).DontLog().RunWithOutput()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return strconv.Atoi(strings.TrimSpace(output))
|
|
}
|