1
0
mirror of https://github.com/jesseduffield/lazygit.git synced 2024-12-16 11:37:01 +02:00
lazygit/pkg/commands/git_commands/rebase.go

425 lines
14 KiB
Go
Raw Normal View History

2022-01-08 05:00:36 +02:00
package git_commands
2020-09-29 12:03:39 +02:00
import (
"fmt"
"path/filepath"
"strings"
"github.com/fsmiamoto/git-todo-parser/todo"
2020-09-29 12:03:39 +02:00
"github.com/go-errors/errors"
2022-03-20 07:19:27 +02:00
"github.com/jesseduffield/generics/slices"
"github.com/jesseduffield/lazygit/pkg/app/daemon"
"github.com/jesseduffield/lazygit/pkg/commands/models"
2021-12-07 12:59:36 +02:00
"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
"github.com/jesseduffield/lazygit/pkg/utils"
2020-09-29 12:03:39 +02:00
)
2022-01-02 01:34:33 +02:00
type RebaseCommands struct {
*GitCommon
commit *CommitCommands
workingTree *WorkingTreeCommands
2022-01-02 01:34:33 +02:00
onSuccessfulContinue func() error
}
func NewRebaseCommands(
gitCommon *GitCommon,
2022-01-02 01:34:33 +02:00
commitCommands *CommitCommands,
workingTreeCommands *WorkingTreeCommands,
) *RebaseCommands {
return &RebaseCommands{
GitCommon: gitCommon,
2022-01-02 01:34:33 +02:00
commit: commitCommands,
workingTree: workingTreeCommands,
}
}
2022-01-09 04:36:07 +02:00
func (self *RebaseCommands) RewordCommit(commits []*models.Commit, index int, message string) error {
if models.IsHeadCommit(commits, index) {
2022-01-09 04:36:07 +02:00
// we've selected the top commit so no rebase is required
return self.commit.RewordLastCommit(message)
}
err := self.BeginInteractiveRebaseForCommit(commits, index)
if err != nil {
return err
}
// now the selected commit should be our head so we'll amend it with the new message
err = self.commit.RewordLastCommit(message)
if err != nil {
return err
}
return self.ContinueRebase()
}
func (self *RebaseCommands) RewordCommitInEditor(commits []*models.Commit, index int) (oscommands.ICmdObj, error) {
2022-03-20 07:19:27 +02:00
todo, sha, err := self.BuildSingleActionTodo(commits, index, "reword")
2020-09-29 12:03:39 +02:00
if err != nil {
return nil, err
}
return self.PrepareInteractiveRebaseCommand(sha, todo, false, false), nil
2020-09-29 12:03:39 +02:00
}
func (self *RebaseCommands) ResetCommitAuthor(commits []*models.Commit, index int) error {
return self.GenericAmend(commits, index, func() error {
return self.commit.ResetAuthor()
})
}
func (self *RebaseCommands) SetCommitAuthor(commits []*models.Commit, index int, value string) error {
return self.GenericAmend(commits, index, func() error {
return self.commit.SetAuthor(value)
})
}
func (self *RebaseCommands) GenericAmend(commits []*models.Commit, index int, f func() error) error {
if index == 0 {
// we've selected the top commit so no rebase is required
return f()
}
err := self.BeginInteractiveRebaseForCommit(commits, index)
if err != nil {
return err
}
// now the selected commit should be our head so we'll amend it
err = f()
if err != nil {
return err
}
return self.ContinueRebase()
}
2022-01-02 01:34:33 +02:00
func (self *RebaseCommands) MoveCommitDown(commits []*models.Commit, index int) error {
// not appending to original slice so that we don't mutate it
orderedCommits := append([]*models.Commit{}, commits[0:index]...)
orderedCommits = append(orderedCommits, commits[index+1], commits[index])
2020-09-29 12:03:39 +02:00
2022-03-20 07:19:27 +02:00
todoLines := self.BuildTodoLinesSingleAction(orderedCommits, "pick")
baseShaOrRoot := getBaseShaOrRoot(commits, index+2)
return self.PrepareInteractiveRebaseCommand(baseShaOrRoot, todoLines, true, false).Run()
2020-09-29 12:03:39 +02:00
}
2022-01-02 01:34:33 +02:00
func (self *RebaseCommands) InteractiveRebase(commits []*models.Commit, index int, action string) error {
2022-03-20 07:19:27 +02:00
todo, sha, err := self.BuildSingleActionTodo(commits, index, action)
2020-09-29 12:03:39 +02:00
if err != nil {
return err
}
return self.PrepareInteractiveRebaseCommand(sha, todo, true, false).Run()
2020-09-29 12:03:39 +02:00
}
func (self *RebaseCommands) InteractiveRebaseBreakAfter(commits []*models.Commit, index int) error {
todo, sha, err := self.BuildSingleActionTodo(commits, index-1, "pick")
if err != nil {
return err
}
todo = append(todo, TodoLine{Action: "break", Commit: nil})
return self.PrepareInteractiveRebaseCommand(sha, todo, true, false).Run()
}
func (self *RebaseCommands) EditRebase(branchRef string) error {
commands := []TodoLine{{Action: "break"}}
return self.PrepareInteractiveRebaseCommand(branchRef, commands, false, true).Run()
}
2020-09-29 12:03:39 +02:00
// PrepareInteractiveRebaseCommand returns the cmd for an interactive rebase
// we tell git to run lazygit to edit the todo list, and we pass the client
// lazygit a todo string to write to the todo file
func (self *RebaseCommands) PrepareInteractiveRebaseCommand(baseShaOrRoot string, todoLines []TodoLine, overrideEditor bool, prepend bool) oscommands.ICmdObj {
2022-03-20 07:19:27 +02:00
todo := self.buildTodo(todoLines)
2022-01-05 03:01:59 +02:00
ex := oscommands.GetLazygitPath()
prependLines := ""
if prepend {
prependLines = "TRUE"
}
2020-09-29 12:03:39 +02:00
debug := "FALSE"
2022-01-02 01:34:33 +02:00
if self.Debug {
2020-09-29 12:03:39 +02:00
debug = "TRUE"
}
cmdStr := fmt.Sprintf("git rebase --interactive --autostash --keep-empty --empty=keep --no-autosquash %s", baseShaOrRoot)
self.Log.WithField("command", cmdStr).Debug("RunCommand")
2020-09-29 12:03:39 +02:00
2022-01-02 01:34:33 +02:00
cmdObj := self.cmd.New(cmdStr)
2020-09-29 12:03:39 +02:00
gitSequenceEditor := ex
if todo == "" {
gitSequenceEditor = "true"
} else {
self.os.LogCommand(fmt.Sprintf("Creating TODO file for interactive rebase: \n\n%s", todo), false)
2020-09-29 12:03:39 +02:00
}
2021-12-07 12:59:36 +02:00
cmdObj.AddEnvVars(
daemon.DaemonKindEnvKey+"="+string(daemon.InteractiveRebase),
daemon.RebaseTODOEnvKey+"="+todo,
daemon.PrependLinesEnvKey+"="+prependLines,
2020-09-29 12:03:39 +02:00
"DEBUG="+debug,
"LANG=en_US.UTF-8", // Force using EN as language
"LC_ALL=en_US.UTF-8", // Force using EN as language
"GIT_SEQUENCE_EDITOR="+gitSequenceEditor,
)
if overrideEditor {
2021-12-07 12:59:36 +02:00
cmdObj.AddEnvVars("GIT_EDITOR=" + ex)
2020-09-29 12:03:39 +02:00
}
2022-01-09 04:36:07 +02:00
return cmdObj
2020-09-29 12:03:39 +02:00
}
2022-03-20 07:19:27 +02:00
// produces TodoLines where every commit is picked (or dropped for merge commits) except for the commit at the given index, which
// will have the given action applied to it.
func (self *RebaseCommands) BuildSingleActionTodo(commits []*models.Commit, actionIndex int, action string) ([]TodoLine, string, error) {
2020-09-29 12:03:39 +02:00
baseIndex := actionIndex + 1
if action == "squash" || action == "fixup" {
baseIndex++
}
2022-03-20 07:19:27 +02:00
todoLines := self.BuildTodoLines(commits[0:baseIndex], func(commit *models.Commit, i int) string {
2020-09-29 12:03:39 +02:00
if i == actionIndex {
2022-03-20 07:19:27 +02:00
return action
2021-06-05 08:39:59 +02:00
} else if commit.IsMerge() {
2020-09-29 12:03:39 +02:00
// your typical interactive rebase will actually drop merge commits by default. Damn git CLI, you scary!
// doing this means we don't need to worry about rebasing over merges which always causes problems.
// you typically shouldn't be doing rebases that pass over merge commits anyway.
2022-03-20 07:19:27 +02:00
return "drop"
2020-09-29 12:03:39 +02:00
} else {
2022-03-20 07:19:27 +02:00
return "pick"
2020-09-29 12:03:39 +02:00
}
2022-03-20 07:19:27 +02:00
})
2020-09-29 12:03:39 +02:00
baseShaOrRoot := getBaseShaOrRoot(commits, baseIndex)
return todoLines, baseShaOrRoot, nil
2020-09-29 12:03:39 +02:00
}
// AmendTo amends the given commit with whatever files are staged
func (self *RebaseCommands) AmendTo(commit *models.Commit) error {
if err := self.commit.CreateFixupCommit(commit.Sha); err != nil {
2020-09-29 12:03:39 +02:00
return err
}
return self.SquashAllAboveFixupCommits(commit)
2020-09-29 12:03:39 +02:00
}
// EditRebaseTodo sets the action for a given rebase commit in the git-rebase-todo file
func (self *RebaseCommands) EditRebaseTodo(commit *models.Commit, action todo.TodoCommand) error {
2022-01-02 01:34:33 +02:00
fileName := filepath.Join(self.dotGitDir, "rebase-merge/git-rebase-todo")
todos, err := utils.ReadRebaseTodoFile(fileName)
2020-09-29 12:03:39 +02:00
if err != nil {
return err
}
for i := range todos {
t := &todos[i]
// Comparing just the sha is not enough; we need to compare both the
// action and the sha, as the sha could appear multiple times (e.g. in a
// pick and later in a merge)
if t.Command == commit.Action && t.Commit == commit.Sha {
t.Command = action
return utils.WriteRebaseTodoFile(fileName, todos)
}
}
2020-09-29 12:03:39 +02:00
// Should never get here
return fmt.Errorf("Todo %s not found in git-rebase-todo", commit.Sha)
2020-09-29 12:03:39 +02:00
}
2023-04-04 10:23:50 +02:00
// MoveTodoDown moves a rebase todo item down by one position
func (self *RebaseCommands) MoveTodoDown(commit *models.Commit) error {
fileName := filepath.Join(self.dotGitDir, "rebase-merge/git-rebase-todo")
return utils.MoveTodoDown(fileName, commit.Sha, commit.Action)
2020-09-29 12:03:39 +02:00
}
// MoveTodoDown moves a rebase todo item down by one position
2023-04-04 10:23:50 +02:00
func (self *RebaseCommands) MoveTodoUp(commit *models.Commit) error {
2022-01-02 01:34:33 +02:00
fileName := filepath.Join(self.dotGitDir, "rebase-merge/git-rebase-todo")
2023-04-04 10:23:50 +02:00
return utils.MoveTodoUp(fileName, commit.Sha, commit.Action)
2020-09-29 12:03:39 +02:00
}
// SquashAllAboveFixupCommits squashes all fixup! commits above the given one
func (self *RebaseCommands) SquashAllAboveFixupCommits(commit *models.Commit) error {
shaOrRoot := commit.Sha + "^"
if commit.IsFirstCommit() {
shaOrRoot = "--root"
}
2022-01-02 01:34:33 +02:00
return self.runSkipEditorCommand(
2022-01-07 11:33:34 +02:00
self.cmd.New(
fmt.Sprintf(
"git rebase --interactive --rebase-merges --autostash --autosquash %s",
shaOrRoot,
2022-01-07 11:33:34 +02:00
),
2020-09-29 12:03:39 +02:00
),
)
}
// BeginInteractiveRebaseForCommit starts an interactive rebase to edit the current
2022-01-09 04:36:07 +02:00
// commit and pick all others. After this you'll want to call `self.ContinueRebase()
2022-01-02 01:34:33 +02:00
func (self *RebaseCommands) BeginInteractiveRebaseForCommit(commits []*models.Commit, commitIndex int) error {
2020-09-29 12:03:39 +02:00
if len(commits)-1 < commitIndex {
return errors.New("index outside of range of commits")
}
// we can make this GPG thing possible it just means we need to do this in two parts:
// one where we handle the possibility of a credential request, and the other
// where we continue the rebase
2022-01-02 01:34:33 +02:00
if self.config.UsingGpg() {
return errors.New(self.Tr.DisabledForGPG)
2020-09-29 12:03:39 +02:00
}
2022-03-20 07:19:27 +02:00
todo, sha, err := self.BuildSingleActionTodo(commits, commitIndex, "edit")
2020-09-29 12:03:39 +02:00
if err != nil {
return err
}
return self.PrepareInteractiveRebaseCommand(sha, todo, true, false).Run()
2020-09-29 12:03:39 +02:00
}
// RebaseBranch interactive rebases onto a branch
2022-01-02 01:34:33 +02:00
func (self *RebaseCommands) RebaseBranch(branchName string) error {
return self.PrepareInteractiveRebaseCommand(branchName, nil, false, false).Run()
2020-09-29 12:03:39 +02:00
}
2022-01-07 11:33:34 +02:00
func (self *RebaseCommands) GenericMergeOrRebaseActionCmdObj(commandType string, command string) oscommands.ICmdObj {
return self.cmd.New("git " + commandType + " --" + command)
}
2022-01-09 04:36:07 +02:00
func (self *RebaseCommands) ContinueRebase() error {
return self.GenericMergeOrRebaseAction("rebase", "continue")
}
func (self *RebaseCommands) AbortRebase() error {
return self.GenericMergeOrRebaseAction("rebase", "abort")
}
2020-09-29 12:03:39 +02:00
// GenericMerge takes a commandType of "merge" or "rebase" and a command of "abort", "skip" or "continue"
// By default we skip the editor in the case where a commit will be made
2022-01-02 01:34:33 +02:00
func (self *RebaseCommands) GenericMergeOrRebaseAction(commandType string, command string) error {
2022-01-07 11:33:34 +02:00
err := self.runSkipEditorCommand(self.GenericMergeOrRebaseActionCmdObj(commandType, command))
2020-09-29 12:03:39 +02:00
if err != nil {
if !strings.Contains(err.Error(), "no rebase in progress") {
return err
}
2022-01-02 01:34:33 +02:00
self.Log.Warn(err)
2020-09-29 12:03:39 +02:00
}
// sometimes we need to do a sequence of things in a rebase but the user needs to
// fix merge conflicts along the way. When this happens we queue up the next step
// so that after the next successful rebase continue we can continue from where we left off
2022-01-02 01:34:33 +02:00
if commandType == "rebase" && command == "continue" && self.onSuccessfulContinue != nil {
f := self.onSuccessfulContinue
self.onSuccessfulContinue = nil
2020-09-29 12:03:39 +02:00
return f()
}
if command == "abort" {
2022-01-02 01:34:33 +02:00
self.onSuccessfulContinue = nil
2020-09-29 12:03:39 +02:00
}
return nil
}
2022-01-07 11:33:34 +02:00
func (self *RebaseCommands) runSkipEditorCommand(cmdObj oscommands.ICmdObj) error {
2022-01-05 03:01:59 +02:00
lazyGitPath := oscommands.GetLazygitPath()
2021-12-29 05:33:38 +02:00
return cmdObj.
AddEnvVars(
daemon.DaemonKindEnvKey+"="+string(daemon.ExitImmediately),
2021-12-29 05:33:38 +02:00
"GIT_EDITOR="+lazyGitPath,
"GIT_SEQUENCE_EDITOR="+lazyGitPath,
2021-12-29 05:33:38 +02:00
"EDITOR="+lazyGitPath,
"VISUAL="+lazyGitPath,
).
Run()
2020-09-29 12:03:39 +02:00
}
2022-01-02 01:34:33 +02:00
// DiscardOldFileChanges discards changes to a file from an old commit
func (self *RebaseCommands) DiscardOldFileChanges(commits []*models.Commit, commitIndex int, fileName string) error {
if err := self.BeginInteractiveRebaseForCommit(commits, commitIndex); err != nil {
return err
}
// check if file exists in previous commit (this command returns an error if the file doesn't exist)
if err := self.cmd.New("git cat-file -e HEAD^:" + self.cmd.Quote(fileName)).Run(); err != nil {
if err := self.os.Remove(fileName); err != nil {
2022-01-02 01:34:33 +02:00
return err
}
if err := self.workingTree.StageFile(fileName); err != nil {
return err
}
} else if err := self.workingTree.CheckoutFile("HEAD^", fileName); err != nil {
return err
}
// amend the commit
err := self.commit.AmendHead()
if err != nil {
return err
}
// continue
2022-01-09 04:36:07 +02:00
return self.ContinueRebase()
2022-01-02 01:34:33 +02:00
}
// CherryPickCommits begins an interactive rebase with the given shas being cherry picked onto HEAD
func (self *RebaseCommands) CherryPickCommits(commits []*models.Commit) error {
2022-03-20 07:19:27 +02:00
todoLines := self.BuildTodoLinesSingleAction(commits, "pick")
return self.PrepareInteractiveRebaseCommand("HEAD", todoLines, false, false).Run()
2022-03-20 07:19:27 +02:00
}
func (self *RebaseCommands) buildTodo(todoLines []TodoLine) string {
lines := slices.Map(todoLines, func(todoLine TodoLine) string {
return todoLine.ToString()
})
return strings.Join(slices.Reverse(lines), "")
}
func (self *RebaseCommands) BuildTodoLines(commits []*models.Commit, f func(*models.Commit, int) string) []TodoLine {
return slices.MapWithIndex(commits, func(commit *models.Commit, i int) TodoLine {
return TodoLine{Action: f(commit, i), Commit: commit}
})
}
func (self *RebaseCommands) BuildTodoLinesSingleAction(commits []*models.Commit, action string) []TodoLine {
return self.BuildTodoLines(commits, func(commit *models.Commit, i int) string {
return action
})
}
type TodoLine struct {
Action string
Commit *models.Commit
}
2022-01-02 01:34:33 +02:00
2022-03-20 07:19:27 +02:00
func (self *TodoLine) ToString() string {
if self.Action == "break" {
return self.Action + "\n"
} else {
return self.Action + " " + self.Commit.Sha + " " + self.Commit.Name + "\n"
}
2022-01-02 01:34:33 +02:00
}
// we can't start an interactive rebase from the first commit without passing the
// '--root' arg
func getBaseShaOrRoot(commits []*models.Commit, index int) string {
// We assume that the commits slice contains the initial commit of the repo.
// Technically this assumption could prove false, but it's unlikely you'll
// be starting a rebase from 300 commits ago (which is the original commit limit
// at time of writing)
if index < len(commits) {
return commits[index].Sha
} else {
return "--root"
}
}