2022-01-08 05:00:36 +02:00
|
|
|
package git_commands
|
2020-09-29 12:03:39 +02:00
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
|
|
|
|
2023-04-03 12:42:29 +02:00
|
|
|
"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"
|
2022-05-07 07:23:08 +02:00
|
|
|
"github.com/jesseduffield/lazygit/pkg/app/daemon"
|
2020-09-29 12:28:39 +02:00
|
|
|
"github.com/jesseduffield/lazygit/pkg/commands/models"
|
2021-12-07 12:59:36 +02:00
|
|
|
"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
|
2023-04-02 19:16:28 +02:00
|
|
|
"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 {
|
2022-01-18 12:26:21 +02:00
|
|
|
*GitCommon
|
|
|
|
commit *CommitCommands
|
|
|
|
workingTree *WorkingTreeCommands
|
2022-01-02 01:34:33 +02:00
|
|
|
|
|
|
|
onSuccessfulContinue func() error
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewRebaseCommands(
|
2022-01-18 12:26:21 +02:00
|
|
|
gitCommon *GitCommon,
|
2022-01-02 01:34:33 +02:00
|
|
|
commitCommands *CommitCommands,
|
|
|
|
workingTreeCommands *WorkingTreeCommands,
|
|
|
|
) *RebaseCommands {
|
|
|
|
return &RebaseCommands{
|
2022-01-18 12:26:21 +02:00
|
|
|
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 {
|
2023-03-03 20:53:15 +02:00
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2023-03-29 00:49:19 +02:00
|
|
|
return self.PrepareInteractiveRebaseCommand(sha, todo, false, false), nil
|
2020-09-29 12:03:39 +02:00
|
|
|
}
|
|
|
|
|
2022-04-22 16:01:30 +02:00
|
|
|
func (self *RebaseCommands) ResetCommitAuthor(commits []*models.Commit, index int) error {
|
2022-05-08 13:05:01 +02:00
|
|
|
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 {
|
2022-04-22 16:01:30 +02:00
|
|
|
if index == 0 {
|
|
|
|
// we've selected the top commit so no rebase is required
|
2022-05-08 13:05:01 +02:00
|
|
|
return f()
|
2022-04-22 16:01:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
err := self.BeginInteractiveRebaseForCommit(commits, index)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2022-05-08 13:05:01 +02:00
|
|
|
// now the selected commit should be our head so we'll amend it
|
|
|
|
err = f()
|
2022-04-22 16:01:30 +02:00
|
|
|
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 {
|
2023-02-22 10:36:31 +02:00
|
|
|
// 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")
|
|
|
|
|
2023-02-22 10:36:31 +02:00
|
|
|
baseShaOrRoot := getBaseShaOrRoot(commits, index+2)
|
|
|
|
|
2023-03-29 00:49:19 +02:00
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2023-03-29 00:49:19 +02:00
|
|
|
return self.PrepareInteractiveRebaseCommand(sha, todo, true, false).Run()
|
2020-09-29 12:03:39 +02:00
|
|
|
}
|
|
|
|
|
2023-02-18 17:12:41 +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})
|
2023-03-29 00:49:19 +02:00
|
|
|
return self.PrepareInteractiveRebaseCommand(sha, todo, true, false).Run()
|
2023-02-18 17:12:41 +02:00
|
|
|
}
|
|
|
|
|
2023-03-29 00:53:14 +02:00
|
|
|
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
|
2023-03-29 00:49:19 +02:00
|
|
|
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()
|
2023-03-29 00:49:19 +02:00
|
|
|
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"
|
|
|
|
}
|
|
|
|
|
2023-03-18 09:17:47 +02:00
|
|
|
cmdStr := fmt.Sprintf("git rebase --interactive --autostash --keep-empty --empty=keep --no-autosquash %s", baseShaOrRoot)
|
2022-08-01 12:04:22 +02:00
|
|
|
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"
|
2021-04-11 03:42:08 +02:00
|
|
|
} else {
|
2022-01-18 12:26:21 +02:00
|
|
|
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(
|
2022-05-07 07:23:08 +02:00
|
|
|
daemon.DaemonKindEnvKey+"="+string(daemon.InteractiveRebase),
|
|
|
|
daemon.RebaseTODOEnvKey+"="+todo,
|
2023-03-29 00:49:19 +02:00
|
|
|
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
|
|
|
|
2023-02-22 10:36:31 +02:00
|
|
|
baseShaOrRoot := getBaseShaOrRoot(commits, baseIndex)
|
2023-02-19 16:20:00 +02:00
|
|
|
|
2023-02-22 10:36:31 +02:00
|
|
|
return todoLines, baseShaOrRoot, nil
|
2020-09-29 12:03:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// AmendTo amends the given commit with whatever files are staged
|
2023-02-20 09:29:43 +02:00
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2023-02-20 09:29:43 +02:00
|
|
|
return self.SquashAllAboveFixupCommits(commit)
|
2020-09-29 12:03:39 +02:00
|
|
|
}
|
|
|
|
|
2023-04-02 19:16:28 +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")
|
2023-04-02 19:16:28 +02:00
|
|
|
todos, err := utils.ReadRebaseTodoFile(fileName)
|
2020-09-29 12:03:39 +02:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2023-04-02 19:16:28 +02:00
|
|
|
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
|
|
|
|
2023-04-02 19:16:28 +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
|
2023-02-20 09:29:43 +02:00
|
|
|
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(
|
2023-02-20 09:29:43 +02:00
|
|
|
"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
|
|
|
|
}
|
|
|
|
|
2023-03-29 00:49:19 +02:00
|
|
|
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 {
|
2023-03-29 00:49:19 +02:00
|
|
|
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(
|
2022-05-07 07:23:08 +02:00
|
|
|
daemon.DaemonKindEnvKey+"="+string(daemon.ExitImmediately),
|
2021-12-29 05:33:38 +02:00
|
|
|
"GIT_EDITOR="+lazyGitPath,
|
2023-01-01 05:33:58 +02:00
|
|
|
"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 {
|
2022-01-18 12:26:21 +02:00
|
|
|
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")
|
|
|
|
|
2023-03-29 00:49:19 +02:00
|
|
|
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 {
|
2023-02-18 17:12:41 +02:00
|
|
|
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
|
|
|
}
|
2023-02-22 10:36:31 +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"
|
|
|
|
}
|
|
|
|
}
|