diff options
Diffstat (limited to 'pkg/commands/loaders/commits.go')
-rw-r--r-- | pkg/commands/loaders/commits.go | 457 |
1 files changed, 457 insertions, 0 deletions
diff --git a/pkg/commands/loaders/commits.go b/pkg/commands/loaders/commits.go new file mode 100644 index 000000000..5fc2caa98 --- /dev/null +++ b/pkg/commands/loaders/commits.go @@ -0,0 +1,457 @@ +package loaders + +import ( + "fmt" + "os" + "path/filepath" + "regexp" + "strconv" + "strings" + + "github.com/jesseduffield/lazygit/pkg/commands/models" + "github.com/jesseduffield/lazygit/pkg/commands/oscommands" + "github.com/jesseduffield/lazygit/pkg/commands/types/enums" + "github.com/jesseduffield/lazygit/pkg/common" + "github.com/jesseduffield/lazygit/pkg/gui/style" +) + +// context: +// here we get the commits from git log but format them to show whether they're +// unpushed/pushed/merged into the base branch or not, or if they're yet to +// be processed as part of a rebase (these won't appear in git log but we +// grab them from the rebase-related files in the .git directory to show them + +const SEPARATION_CHAR = "|" + +// CommitLoader returns a list of Commit objects for the current repo +type CommitLoader struct { + *common.Common + cmd oscommands.ICmdObjBuilder + + getCurrentBranchName func() (string, string, error) + getRebaseMode func() (enums.RebaseMode, error) + readFile func(filename string) ([]byte, error) + walkFiles func(root string, fn filepath.WalkFunc) error + dotGitDir string +} + +func NewCommitLoader( + common *common.Common, + cmd oscommands.ICmdObjBuilder, + getCurrentBranchName func() (string, string, error), + getRebaseMode func() (enums.RebaseMode, error), + readFile func(filename string) ([]byte, error), + walkFiles func(root string, fn filepath.WalkFunc) error, + dotGitDir string, +) *CommitLoader { + return &CommitLoader{ + Common: common, + cmd: cmd, + getCurrentBranchName: getCurrentBranchName, + getRebaseMode: getRebaseMode, + readFile: readFile, + walkFiles: walkFiles, + dotGitDir: dotGitDir, + } +} + +type GetCommitsOptions struct { + Limit bool + FilterPath string + IncludeRebaseCommits bool + RefName string // e.g. "HEAD" or "my_branch" + // determines if we show the whole git graph i.e. pass the '--all' flag + All bool +} + +// GetCommits obtains the commits of the current branch +func (self *CommitLoader) GetCommits(opts GetCommitsOptions) ([]*models.Commit, error) { + commits := []*models.Commit{} + var rebasingCommits []*models.Commit + rebaseMode, err := self.getRebaseMode() + if err != nil { + return nil, err + } + + if opts.IncludeRebaseCommits && opts.FilterPath == "" { + var err error + rebasingCommits, err = self.MergeRebasingCommits(commits) + if err != nil { + return nil, err + } + commits = append(commits, rebasingCommits...) + } + + passedFirstPushedCommit := false + firstPushedCommit, err := self.getFirstPushedCommit(opts.RefName) + if err != nil { + // must have no upstream branch so we'll consider everything as pushed + passedFirstPushedCommit = true + } + + err = self.getLogCmd(opts).RunAndProcessLines(func(line string) (bool, error) { + if canExtractCommit(line) { + commit := self.extractCommitFromLine(line) + if commit.Sha == firstPushedCommit { + passedFirstPushedCommit = true + } + commit.Status = map[bool]string{true: "unpushed", false: "pushed"}[!passedFirstPushedCommit] + commits = append(commits, commit) + } + return false, nil + }) + if err != nil { + return nil, err + } + + if len(commits) == 0 { + return commits, nil + } + + if rebaseMode != enums.REBASE_MODE_NONE { + currentCommit := commits[len(rebasingCommits)] + youAreHere := style.FgYellow.Sprintf("<-- %s ---", self.Tr.YouAreHere) + currentCommit.Name = fmt.Sprintf("%s %s", youAreHere, currentCommit.Name) + } + + commits, err = self.setCommitMergedStatuses(opts.RefName, commits) + if err != nil { + return nil, err + } + + return commits, nil +} + +func (self *CommitLoader) MergeRebasingCommits(commits []*models.Commit) ([]*models.Commit, error) { + // chances are we have as many commits as last time so we'll set the capacity to be the old length + result := make([]*models.Commit, 0, len(commits)) + for i, commit := range commits { + if commit.Status != "rebasing" { // removing the existing rebase commits so we can add the refreshed ones + result = append(result, commits[i:]...) + break + } + } + + rebaseMode, err := self.getRebaseMode() + if err != nil { + return nil, err + } + + if rebaseMode == enums.REBASE_MODE_NONE { + // not in rebase mode so return original commits + return result, nil + } + + rebasingCommits, err := self.getHydratedRebasingCommits(rebaseMode) + if err != nil { + return nil, err + } + if len(rebasingCommits) > 0 { + result = append(rebasingCommits, result...) + } + + return result, nil +} + +// extractCommitFromLine takes a line from a git log and extracts the sha, message, date, and tag if present +// then puts them into a commit object +// example input: +// 8ad01fe32fcc20f07bc6693f87aa4977c327f1e1|10 hours ago|Jesse Duffield| (HEAD -> master, tag: v0.15.2)|refresh commits when adding a tag +func (self *CommitLoader) extractCommitFromLine(line string) *models.Commit { + split := strings.Split(line, SEPARATION_CHAR) + + sha := split[0] + unixTimestamp := split[1] + author := split[2] + extraInfo := strings.TrimSpace(split[3]) + parentHashes := split[4] + + message := strings.Join(split[5:], SEPARATION_CHAR) + tags := []string{} + + if extraInfo != "" { + re := regexp.MustCompile(`tag: ([^,\)]+)`) + tagMatch := re.FindStringSubmatch(extraInfo) + if len(tagMatch) > 1 { + tags = append(tags, tagMatch[1]) + } + } + + unitTimestampInt, _ := strconv.Atoi(unixTimestamp) + + return &models.Commit{ + Sha: sha, + Name: message, + Tags: tags, + ExtraInfo: extraInfo, + UnixTimestamp: int64(unitTimestampInt), + Author: author, + Parents: strings.Split(parentHashes, " "), + } +} + +func (self *CommitLoader) getHydratedRebasingCommits(rebaseMode enums.RebaseMode) ([]*models.Commit, error) { + commits, err := self.getRebasingCommits(rebaseMode) + if err != nil { + return nil, err + } + + if len(commits) == 0 { + return nil, nil + } + + commitShas := make([]string, len(commits)) + for i, commit := range commits { + commitShas[i] = commit.Sha + } + + // note that we're not filtering these as we do non-rebasing commits just because + // I suspect that will cause some damage + cmdObj := self.cmd.New( + fmt.Sprintf( + "git show %s --no-patch --oneline %s --abbrev=%d", + strings.Join(commitShas, " "), + prettyFormat, + 20, + ), + ) + + hydratedCommits := make([]*models.Commit, 0, len(commits)) + i := 0 + err = cmdObj.RunAndProcessLines(func(line string) (bool, error) { + if canExtractCommit(line) { + commit := self.extractCommitFromLine(line) + matchingCommit := commits[i] + commit.Action = matchingCommit.Action + commit.Status = matchingCommit.Status + hydratedCommits = append(hydratedCommits, commit) + i++ + } + return false, nil + }) + if err != nil { + return nil, err + } + return hydratedCommits, nil +} + +// getRebasingCommits obtains the commits that we're in the process of rebasing +func (self *CommitLoader) getRebasingCommits(rebaseMode enums.RebaseMode) ([]*models.Commit, error) { + switch rebaseMode { + case enums.REBASE_MODE_MERGING: + return self.getNormalRebasingCommits() + case enums.REBASE_MODE_INTERACTIVE: + return self.getInteractiveRebasingCommits() + default: + return nil, nil + } +} + +func (self *CommitLoader) getNormalRebasingCommits() ([]*models.Commit, error) { + rewrittenCount := 0 + bytesContent, err := self.readFile(filepath.Join(self.dotGitDir, "rebase-apply/rewritten")) + if err == nil { + content := string(bytesContent) + rewrittenCount = len(strings.Split(content, "\n")) + } + + // we know we're rebasing, so lets get all the files whose names have numbers + commits := []*models.Commit{} + err = self.walkFiles(filepath.Join(self.dotGitDir, "rebase-apply"), func(path string, f os.FileInfo, err error) error { + if rewrittenCount > 0 { + rewrittenCount-- + return nil + } + if err != nil { + return err + } + re := regexp.MustCompile(`^\d+$`) + if !re.MatchString(f.Name()) { + return nil + } + bytesContent, err := self.readFile(path) + if err != nil { + return err + } + content := string(bytesContent) + commit, err := self.commitFromPatch(content) + if err != nil { + return err + } + commits = append([]*models.Commit{commit}, commits...) + return nil + }) + if err != nil { + return nil, err + } + + return commits, nil +} + +// git-rebase-todo example: +// pick ac446ae94ee560bdb8d1d057278657b251aaef17 ac446ae +// pick afb893148791a2fbd8091aeb81deba4930c73031 afb8931 + +// git-rebase-todo.backup example: +// pick 49cbba374296938ea86bbd4bf4fee2f6ba5cccf6 third commit on master +// pick ac446ae94ee560bdb8d1d057278657b251aaef17 blah commit on master +// pick afb893148791a2fbd8091aeb81deba4930c73031 fourth commit on master + +// getInteractiveRebasingCommits takes our git-rebase-todo and our git-rebase-todo.backup files +// and extracts out the sha and names of commits that we still have to go +// in the rebase: +func (self *CommitLoader) getInteractiveRebasingCommits() ([]*models.Commit, error) { + bytesContent, err := self.readFile(filepath.Join(self.dotGitDir, "rebase-merge/git-rebase-todo")) + if err != nil { + self.Log.Error(fmt.Sprintf("error occurred reading git-rebase-todo: %s", err.Error())) + // we assume an error means the file doesn't exist so we just return + return nil, nil + } + + commits := []*models.Commit{} + lines := strings.Split(string(bytesContent), "\n") + for _, line := range lines { + if line == "" || line == "noop" { + return commits, nil + } + if strings.HasPrefix(line, "#") { + continue + } + splitLine := strings.Split(line, " ") + commits = append([]*models.Commit{{ + Sha: splitLine[1], + Name: strings.Join(splitLine[2:], " "), + Status: "rebasing", + Action: splitLine[0], + }}, commits...) + } + + return commits, nil +} + +// assuming the file starts like this: +// From e93d4193e6dd45ca9cf3a5a273d7ba6cd8b8fb20 Mon Sep 17 00:00:00 2001 +// From: Lazygit Tester <test@example.com> +// Date: Wed, 5 Dec 2018 21:03:23 +1100 +// Subject: second commit on master +func (self *CommitLoader) commitFromPatch(content string) (*models.Commit, error) { + lines := strings.Split(content, "\n") + sha := strings.Split(lines[0], " ")[1] + name := strings.TrimPrefix(lines[3], "Subject: ") + return &models.Commit{ + Sha: sha, + Name: name, + Status: "rebasing", + }, nil +} + +func (self *CommitLoader) setCommitMergedStatuses(refName string, commits []*models.Commit) ([]*models.Commit, error) { + ancestor, err := self.getMergeBase(refName) + if err != nil { + return nil, err + } + if ancestor == "" { + return commits, nil + } + passedAncestor := false + for i, commit := range commits { + if strings.HasPrefix(ancestor, commit.Sha) { + passedAncestor = true + } + if commit.Status != "pushed" { + continue + } + if passedAncestor { + commits[i].Status = "merged" + } + } + return commits, nil +} + +func (self *CommitLoader) getMergeBase(refName string) (string, error) { + currentBranch, _, err := self.getCurrentBranchName() + if err != nil { + return "", err + } + + baseBranch := "master" + if strings.HasPrefix(currentBranch, "feature/") { + baseBranch = "develop" + } + + // swallowing error because it's not a big deal; probably because there are no commits yet + output, _ := self.cmd.New(fmt.Sprintf("git merge-base %s %s", self.cmd.Quote(refName), self.cmd.Quote(baseBranch))).RunWithOutput() + return ignoringWarnings(output), nil +} + +func ignoringWarnings(commandOutput string) string { + trimmedOutput := strings.TrimSpace(commandOutput) + split := strings.Split(trimmedOutput, "\n") + // need to get last line in case the first line is a warning about how the error is ambiguous. + // At some point we should find a way to make it unambiguous + lastLine := split[len(split)-1] + + return lastLine +} + +// getFirstPushedCommit returns the first commit SHA which has been pushed to the ref's upstream. +// all commits above this are deemed unpushed and marked as such. +func (self *CommitLoader) getFirstPushedCommit(refName string) (string, error) { + output, err := self.cmd. + New( + fmt.Sprintf("git merge-base %s %s@{u}", self.cmd.Quote(refName), self.cmd.Quote(refName)), + ). + RunWithOutput() + if err != nil { + return "", err + } + + return ignoringWarnings(output), nil +} + +// getLog gets the git log. +func (self *CommitLoader) getLogCmd(opts GetCommitsOptions) oscommands.ICmdObj { + limitFlag := "" + if opts.Limit { + limitFlag = " -300" + } + + filterFlag := "" + if opts.FilterPath != "" { + filterFlag = fmt.Sprintf(" --follow -- %s", self.cmd.Quote(opts.FilterPath)) + } + + config := self.UserConfig.Git.Log + + orderFlag := "--" + config.Order + allFlag := "" + if opts.All { + allFlag = " --all" + } + + return self.cmd.New( + fmt.Sprintf( + "git log %s %s %s --oneline %s%s --abbrev=%d%s", + self.cmd.Quote(opts.RefName), + orderFlag, + allFlag, + prettyFormat, + limitFlag, + 20, + filterFlag, + ), + ) +} + +var prettyFormat = fmt.Sprintf( + "--pretty=format:\"%%H%s%%at%s%%aN%s%%d%s%%p%s%%s\"", + SEPARATION_CHAR, + SEPARATION_CHAR, + SEPARATION_CHAR, + SEPARATION_CHAR, + SEPARATION_CHAR, +) + +func canExtractCommit(line string) bool { + return line != "" && strings.Split(line, " ")[0] != "gpg:" +} |