1
0
mirror of https://github.com/jesseduffield/lazygit.git synced 2024-12-14 11:23:09 +02:00
lazygit/pkg/commands/git_commands/branch_loader.go

254 lines
6.9 KiB
Go
Raw Normal View History

package git_commands
import (
2022-11-07 07:35:36 +02:00
"fmt"
"regexp"
"strings"
2022-03-19 03:26:30 +02:00
"github.com/jesseduffield/generics/set"
"github.com/jesseduffield/go-git/v5/config"
"github.com/jesseduffield/lazygit/pkg/commands/models"
2022-11-07 07:35:36 +02:00
"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
"github.com/jesseduffield/lazygit/pkg/common"
2018-08-13 12:26:02 +02:00
"github.com/jesseduffield/lazygit/pkg/utils"
2022-11-07 07:35:36 +02:00
"github.com/samber/lo"
"golang.org/x/exp/slices"
)
// context:
// we want to only show 'safe' branches (ones that haven't e.g. been deleted)
// which `git branch -a` gives us, but we also want the recency data that
// git reflog gives us.
// So we get the HEAD, then append get the reflog branches that intersect with
// our safe branches, then add the remaining safe branches, ensuring uniqueness
// along the way
// if we find out we need to use one of these functions in the git.go file, we
// can just pull them out of here and put them there and then call them from in here
type BranchLoaderConfigCommands interface {
Branches() (map[string]*config.Branch, error)
}
type BranchInfo struct {
RefName string
DisplayName string // e.g. '(HEAD detached at 123asdf)'
DetachedHead bool
}
2021-12-30 04:44:41 +02:00
// BranchLoader returns a list of Branch objects for the current repo
type BranchLoader struct {
*common.Common
2022-11-07 07:35:36 +02:00
cmd oscommands.ICmdObjBuilder
getCurrentBranchInfo func() (BranchInfo, error)
config BranchLoaderConfigCommands
2018-08-12 13:04:47 +02:00
}
2021-12-30 04:44:41 +02:00
func NewBranchLoader(
cmn *common.Common,
2022-11-07 07:35:36 +02:00
cmd oscommands.ICmdObjBuilder,
getCurrentBranchInfo func() (BranchInfo, error),
config BranchLoaderConfigCommands,
2021-12-30 04:44:41 +02:00
) *BranchLoader {
return &BranchLoader{
Common: cmn,
2022-11-07 07:35:36 +02:00
cmd: cmd,
getCurrentBranchInfo: getCurrentBranchInfo,
config: config,
}
}
2021-12-30 04:44:41 +02:00
// Load the list of branches for the current repo
func (self *BranchLoader) Load(reflogCommits []*models.Commit) ([]*models.Branch, error) {
2021-12-30 08:19:01 +02:00
branches := self.obtainBranches()
2021-12-29 05:33:38 +02:00
reflogBranches := self.obtainReflogBranches(reflogCommits)
2021-12-29 05:33:38 +02:00
// loop through reflog branches. If there is a match, merge them, then remove it from the branches and keep it in the reflog branches
branchesWithRecency := make([]*models.Branch, 0)
outer:
for _, reflogBranch := range reflogBranches {
for j, branch := range branches {
if branch.Head {
continue
}
if strings.EqualFold(reflogBranch.Name, branch.Name) {
branch.Recency = reflogBranch.Recency
branchesWithRecency = append(branchesWithRecency, branch)
branches = utils.Remove(branches, j)
2021-12-29 05:33:38 +02:00
continue outer
}
}
}
// Sort branches that don't have a recency value alphabetically
// (we're really doing this for the sake of deterministic behaviour across git versions)
slices.SortFunc(branches, func(a *models.Branch, b *models.Branch) bool {
return a.Name < b.Name
})
branches = utils.Prepend(branches, branchesWithRecency...)
2021-12-29 05:33:38 +02:00
foundHead := false
for i, branch := range branches {
if branch.Head {
foundHead = true
branch.Recency = " *"
branches = utils.Move(branches, i, 0)
2021-12-29 05:33:38 +02:00
break
}
}
if !foundHead {
info, err := self.getCurrentBranchInfo()
2021-12-29 05:33:38 +02:00
if err != nil {
return nil, err
2021-12-29 05:33:38 +02:00
}
branches = utils.Prepend(branches, &models.Branch{Name: info.RefName, DisplayName: info.DisplayName, Head: true, DetachedHead: info.DetachedHead, Recency: " *"})
2021-12-29 05:33:38 +02:00
}
configBranches, err := self.config.Branches()
if err != nil {
return nil, err
}
for _, branch := range branches {
match := configBranches[branch.Name]
if match != nil {
branch.UpstreamRemote = match.Remote
branch.UpstreamBranch = match.Merge.Short()
}
}
return branches, nil
2021-12-29 05:33:38 +02:00
}
2022-03-24 09:14:49 +02:00
func (self *BranchLoader) obtainBranches() []*models.Branch {
output, err := self.getRawBranches()
if err != nil {
panic(err)
}
trimmedOutput := strings.TrimSpace(output)
outputLines := strings.Split(trimmedOutput, "\n")
return lo.FilterMap(outputLines, func(line string, _ int) (*models.Branch, bool) {
2022-03-24 09:14:49 +02:00
if line == "" {
return nil, false
}
2022-03-26 14:55:44 +02:00
split := strings.Split(line, "\x00")
2022-11-07 07:35:36 +02:00
if len(split) != len(branchFields) {
// Ignore line if it isn't separated into the expected number of parts
2022-03-24 09:14:49 +02:00
// This is probably a warning message, for more info see:
// https://github.com/jesseduffield/lazygit/issues/1385#issuecomment-885580439
return nil, false
}
return obtainBranch(split), true
2022-03-24 09:14:49 +02:00
})
}
2022-11-07 07:35:36 +02:00
func (self *BranchLoader) getRawBranches() (string, error) {
format := strings.Join(
lo.Map(branchFields, func(thing string, _ int) string {
return "%(" + thing + ")"
}),
"%00",
)
cmdArgs := NewGitCmd("for-each-ref").
Arg("--sort=-committerdate").
Arg(fmt.Sprintf("--format=%s", format)).
Arg("refs/heads").
ToArgv()
return self.cmd.New(cmdArgs).DontLog().RunWithOutput()
}
var branchFields = []string{
"HEAD",
"refname:short",
"upstream:short",
"upstream:track",
"subject",
fmt.Sprintf("objectname:short=%d", utils.COMMIT_HASH_SHORT_SIZE),
}
2022-03-24 08:49:25 +02:00
// Obtain branch information from parsed line output of getRawBranches()
func obtainBranch(split []string) *models.Branch {
2022-11-07 07:35:36 +02:00
headMarker := split[0]
fullName := split[1]
upstreamName := split[2]
track := split[3]
subject := split[4]
commitHash := split[5]
name := strings.TrimPrefix(fullName, "heads/")
pushables, pullables, gone := parseUpstreamInfo(upstreamName, track)
return &models.Branch{
Name: name,
Pushables: pushables,
Pullables: pullables,
UpstreamGone: gone,
Head: headMarker == "*",
Subject: subject,
CommitHash: commitHash,
2022-03-24 08:49:25 +02:00
}
2022-11-07 07:35:36 +02:00
}
2022-03-24 08:49:25 +02:00
2022-11-07 07:35:36 +02:00
func parseUpstreamInfo(upstreamName string, track string) (string, string, bool) {
2022-03-24 08:49:25 +02:00
if upstreamName == "" {
// if we're here then it means we do not have a local version of the remote.
// The branch might still be tracking a remote though, we just don't know
// how many commits ahead/behind it is
2022-11-07 07:35:36 +02:00
return "?", "?", false
2022-03-24 08:49:25 +02:00
}
if track == "[gone]" {
2022-11-07 07:35:36 +02:00
return "?", "?", true
2022-03-24 08:49:25 +02:00
}
2022-11-07 07:35:36 +02:00
pushables := parseDifference(track, `ahead (\d+)`)
pullables := parseDifference(track, `behind (\d+)`)
return pushables, pullables, false
}
func parseDifference(track string, regexStr string) string {
re := regexp.MustCompile(regexStr)
match := re.FindStringSubmatch(track)
if len(match) > 1 {
return match[1]
} else {
return "0"
}
2022-03-24 08:49:25 +02:00
}
// TODO: only look at the new reflog commits, and otherwise store the recencies in
// int form against the branch to recalculate the time ago
func (self *BranchLoader) obtainReflogBranches(reflogCommits []*models.Commit) []*models.Branch {
2022-03-19 03:26:30 +02:00
foundBranches := set.New[string]()
re := regexp.MustCompile(`checkout: moving from ([\S]+) to ([\S]+)`)
reflogBranches := make([]*models.Branch, 0, len(reflogCommits))
2022-03-19 07:34:46 +02:00
for _, commit := range reflogCommits {
2022-03-19 07:34:46 +02:00
match := re.FindStringSubmatch(commit.Name)
if len(match) != 3 {
continue
}
recency := utils.UnixToTimeAgo(commit.UnixTimestamp)
for _, branchName := range match[1:] {
if !foundBranches.Includes(branchName) {
foundBranches.Add(branchName)
reflogBranches = append(reflogBranches, &models.Branch{
Recency: recency,
Name: branchName,
})
}
}
}
return reflogBranches
}