Divergence from base branch display (#3613)

- **PR Description**

Add a new config option `showDivergenceFromBaseBranch`; if not "none",
it indicates in the branches view for each branch if it has fallen
behind its base branch, and optionally by how much. If set to
"onlyArrow", it will append `↓` after the branch status; if set to
"arrowAndNumber", it appends `↓17`, where the count indicates how many
commits it is behind the base branch. These are colored in blue, and go
after the existing yellow `↓3↑7` indication of divergence from the
upstream.

The option is off by default, since we are afraid that people may find
this too noisy. We may reconsider this choice in the future if the
response is positive.

- **Please check if the PR fulfills these requirements**

* [x] Cheatsheets are up-to-date (run `go generate ./...`)
* [x] Code has been formatted (see
[here](https://github.com/jesseduffield/lazygit/blob/master/CONTRIBUTING.md#code-formatting))
* [x] Tests have been added/updated (see
[here](https://github.com/jesseduffield/lazygit/blob/master/pkg/integration/README.md)
for the integration test guide)
* [x] Text is internationalised (see
[here](https://github.com/jesseduffield/lazygit/blob/master/CONTRIBUTING.md#internationalisation))
* [x] Docs have been updated if necessary
* [x] You've read through your own file changes for silly mistakes etc

docs/Config.md

@@ -187,6 +187,10 @@ gui:
   # If true, show commit hashes alongside branch names in the branches view.
   showBranchCommitHash: false
 
+  # Whether to show the divergence from the base branch in the branches view.
+  # One of: 'none' | 'onlyArrow'  | 'arrowAndNumber'
+  showDivergenceFromBaseBranch: none
+
   # Height of the command log view
   commandLogSize: 8
 

pkg/commands/git_commands/branch_loader.go

@@ -5,6 +5,7 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/jesseduffield/generics/set"
 	"github.com/jesseduffield/go-git/v5/config"
@@ -14,6 +15,7 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/utils"
 	"github.com/samber/lo"
 	"golang.org/x/exp/slices"
+	"golang.org/x/sync/errgroup"
 )
 
 // context:
@@ -63,7 +65,13 @@ func NewBranchLoader(
 }
 
 // Load the list of branches for the current repo
-func (self *BranchLoader) Load(reflogCommits []*models.Commit) ([]*models.Branch, error) {
+func (self *BranchLoader) Load(reflogCommits []*models.Commit,
+	mainBranches *MainBranches,
+	oldBranches []*models.Branch,
+	loadBehindCounts bool,
+	onWorker func(func() error),
+	renderFunc func(),
+) ([]*models.Branch, error) {
 	branches := self.obtainBranches(self.version.IsAtLeast(2, 22, 0))
 
 	if self.AppState.LocalBranchSortOrder == "recency" {
@@ -122,11 +130,108 @@ func (self *BranchLoader) Load(reflogCommits []*models.Commit) ([]*models.Branch
 			branch.UpstreamRemote = match.Remote
 			branch.UpstreamBranch = match.Merge.Short()
 		}
+
+		// If the branch already existed, take over its BehindBaseBranch value
+		// to reduce flicker
+		if oldBranch, found := lo.Find(oldBranches, func(b *models.Branch) bool {
+			return b.Name == branch.Name
+		}); found {
+			branch.BehindBaseBranch.Store(oldBranch.BehindBaseBranch.Load())
+		}
+	}
+
+	if loadBehindCounts && self.UserConfig.Gui.ShowDivergenceFromBaseBranch != "none" {
+		onWorker(func() error {
+			return self.GetBehindBaseBranchValuesForAllBranches(branches, mainBranches, renderFunc)
+		})
 	}
 
 	return branches, nil
 }
 
+func (self *BranchLoader) GetBehindBaseBranchValuesForAllBranches(
+	branches []*models.Branch,
+	mainBranches *MainBranches,
+	renderFunc func(),
+) error {
+	mainBranchRefs := mainBranches.Get()
+	if len(mainBranchRefs) == 0 {
+		return nil
+	}
+
+	t := time.Now()
+	errg := errgroup.Group{}
+
+	for _, branch := range branches {
+		errg.Go(func() error {
+			baseBranch, err := self.GetBaseBranch(branch, mainBranches)
+			if err != nil {
+				return err
+			}
+			behind := 0 // prime it in case something below fails
+			if baseBranch != "" {
+				output, err := self.cmd.New(
+					NewGitCmd("rev-list").
+						Arg("--left-right").
+						Arg("--count").
+						Arg(fmt.Sprintf("%s...%s", branch.FullRefName(), baseBranch)).
+						ToArgv(),
+				).DontLog().RunWithOutput()
+				if err != nil {
+					return err
+				}
+				// The format of the output is "<ahead>\t<behind>"
+				aheadBehindStr := strings.Split(strings.TrimSpace(output), "\t")
+				if len(aheadBehindStr) == 2 {
+					if value, err := strconv.Atoi(aheadBehindStr[1]); err == nil {
+						behind = value
+					}
+				}
+			}
+			branch.BehindBaseBranch.Store(int32(behind))
+			return nil
+		})
+	}
+
+	err := errg.Wait()
+	self.Log.Debugf("time to get behind base branch values for all branches: %s", time.Since(t))
+	renderFunc()
+	return err
+}
+
+// Find the base branch for the given branch (i.e. the main branch that the
+// given branch was forked off of)
+//
+// Note that this function may return an empty string even if the returned error
+// is nil, e.g. when none of the configured main branches exist. This is not
+// considered an error condition, so callers need to check both the returned
+// error and whether the returned base branch is empty (and possibly react
+// differently in both cases).
+func (self *BranchLoader) GetBaseBranch(branch *models.Branch, mainBranches *MainBranches) (string, error) {
+	mergeBase := mainBranches.GetMergeBase(branch.FullRefName())
+	if mergeBase == "" {
+		return "", nil
+	}
+
+	output, err := self.cmd.New(
+		NewGitCmd("for-each-ref").
+			Arg("--contains").
+			Arg(mergeBase).
+			Arg("--format=%(refname)").
+			Arg(mainBranches.Get()...).
+			ToArgv(),
+	).DontLog().RunWithOutput()
+	if err != nil {
+		return "", err
+	}
+	trimmedOutput := strings.TrimSpace(output)
+	split := strings.Split(trimmedOutput, "\n")
+	if len(split) == 0 || split[0] == "" {
+		return "", nil
+	}
+	return split[0], nil
+}
+
 func (self *BranchLoader) obtainBranches(canUsePushTrack bool) []*models.Branch {
 	output, err := self.getRawBranches()
 	if err != nil {

pkg/commands/git_commands/commit_loader.go

@@ -35,11 +35,6 @@ type CommitLoader struct {
 	readFile      func(filename string) ([]byte, error)
 	walkFiles     func(root string, fn filepath.WalkFunc) error
 	dotGitDir     string
-	// List of main branches that exist in the repo.
-	// We use these to obtain the merge base of the branch.
-	// When nil, we're yet to obtain the list of existing main branches.
-	// When an empty slice, we've obtained the list and it's empty.
-	mainBranches []string
 	*GitCommon
 }
 
@@ -56,7 +51,6 @@ func NewCommitLoader(
 		getRebaseMode: getRebaseMode,
 		readFile:      os.ReadFile,
 		walkFiles:     filepath.Walk,
-		mainBranches:  nil,
 		GitCommon:     gitCommon,
 	}
 }
@@ -72,6 +66,7 @@ type GetCommitsOptions struct {
 	All bool
 	// If non-empty, show divergence from this ref (left-right log)
 	RefToShowDivergenceFrom string
+	MainBranches            *MainBranches
 }
 
 // GetCommits obtains the commits of the current branch
@@ -108,9 +103,9 @@ func (self *CommitLoader) GetCommits(opts GetCommitsOptions) ([]*models.Commit,
 	go utils.Safe(func() {
 		defer wg.Done()
 
-		ancestor = self.getMergeBase(opts.RefName)
+		ancestor = opts.MainBranches.GetMergeBase(opts.RefName)
 		if opts.RefToShowDivergenceFrom != "" {
-			remoteAncestor = self.getMergeBase(opts.RefToShowDivergenceFrom)
+			remoteAncestor = opts.MainBranches.GetMergeBase(opts.RefToShowDivergenceFrom)
 		}
 	})
 
@@ -471,82 +466,6 @@ func setCommitMergedStatuses(ancestor string, commits []*models.Commit) {
 	}
 }
 
-func (self *CommitLoader) getMergeBase(refName string) string {
-	if self.mainBranches == nil {
-		self.mainBranches = self.getExistingMainBranches()
-	}
-
-	if len(self.mainBranches) == 0 {
-		return ""
-	}
-
-	// We pass all configured main branches to the merge-base call; git will
-	// return the base commit for the closest one.
-
-	output, err := self.cmd.New(
-		NewGitCmd("merge-base").Arg(refName).Arg(self.mainBranches...).
-			ToArgv(),
-	).DontLog().RunWithOutput()
-	if err != nil {
-		// If there's an error, it must be because one of the main branches that
-		// used to exist when we called getExistingMainBranches() was deleted
-		// meanwhile. To fix this for next time, throw away our cache.
-		self.mainBranches = nil
-	}
-	return ignoringWarnings(output)
-}
-
-func (self *CommitLoader) getExistingMainBranches() []string {
-	var existingBranches []string
-	var wg sync.WaitGroup
-
-	mainBranches := self.UserConfig.Git.MainBranches
-	existingBranches = make([]string, len(mainBranches))
-
-	for i, branchName := range mainBranches {
-		wg.Add(1)
-		go utils.Safe(func() {
-			defer wg.Done()
-
-			// Try to determine upstream of local main branch
-			if ref, err := self.cmd.New(
-				NewGitCmd("rev-parse").Arg("--symbolic-full-name", branchName+"@{u}").ToArgv(),
-			).DontLog().RunWithOutput(); err == nil {
-				existingBranches[i] = strings.TrimSpace(ref)
-				return
-			}
-
-			// If this failed, a local branch for this main branch doesn't exist or it
-			// has no upstream configured. Try looking for one in the "origin" remote.
-			ref := "refs/remotes/origin/" + branchName
-			if err := self.cmd.New(
-				NewGitCmd("rev-parse").Arg("--verify", "--quiet", ref).ToArgv(),
-			).DontLog().Run(); err == nil {
-				existingBranches[i] = ref
-				return
-			}
-
-			// If this failed as well, try if we have the main branch as a local
-			// branch. This covers the case where somebody is using git locally
-			// for something, but never pushing anywhere.
-			ref = "refs/heads/" + branchName
-			if err := self.cmd.New(
-				NewGitCmd("rev-parse").Arg("--verify", "--quiet", ref).ToArgv(),
-			).DontLog().Run(); err == nil {
-				existingBranches[i] = ref
-			}
-		})
-	}
-
-	wg.Wait()
-
-	existingBranches = lo.Filter(existingBranches, func(branch string, _ int) bool {
-		return branch != ""
-	})
-
-	return existingBranches
-}
-
 func ignoringWarnings(commandOutput string) string {
 	trimmedOutput := strings.TrimSpace(commandOutput)
 	split := strings.Split(trimmedOutput, "\n")

pkg/commands/git_commands/commit_loader_test.go

@@ -307,10 +307,11 @@ func TestGetCommits(t *testing.T) {
 			common := utils.NewDummyCommon()
 			common.AppState = &config.AppState{}
 			common.AppState.GitLogOrder = scenario.logOrder
+			cmd := oscommands.NewDummyCmdObjBuilder(scenario.runner)
 
 			builder := &CommitLoader{
 				Common:        common,
-				cmd:           oscommands.NewDummyCmdObjBuilder(scenario.runner),
+				cmd:           cmd,
 				getRebaseMode: func() (enums.RebaseMode, error) { return scenario.rebaseMode, nil },
 				dotGitDir:     ".git",
 				readFile: func(filename string) ([]byte, error) {
@@ -322,7 +323,9 @@ func TestGetCommits(t *testing.T) {
 			}
 
 			common.UserConfig.Git.MainBranches = scenario.mainBranches
-			commits, err := builder.GetCommits(scenario.opts)
+			opts := scenario.opts
+			opts.MainBranches = NewMainBranches(scenario.mainBranches, cmd)
+			commits, err := builder.GetCommits(opts)
 
 			assert.Equal(t, scenario.expectedCommits, commits)
 			assert.Equal(t, scenario.expectedError, err)