From 8bfa74a709c06326f2bd385e5d634228167dbca7 Mon Sep 17 00:00:00 2001 From: Stefan Haller Date: Fri, 6 Nov 2026 10:03:42 +0100 Subject: [PATCH] Add a rebase that moves commits on top of a given commit Outside of a rebase, we move commits by a number of rows, skipping the update-ref todos that we don't show. This can't move a commit past the update-ref todos only. We will need that for moving a commit to the end of the branch below it in a stack. It also moves each commit separately, so the update-ref todos between the moved commits stay behind. MoveCommitsTo names the commit that the moved commits are to sit on, and which of the branches that point at that commit are to point at the moved commits instead. The update-ref todos between the moved commits move along with them. Co-Authored-By: Claude Opus 5.5 --- pkg/app/daemon/daemon.go | 28 +++++ pkg/commands/git_commands/rebase.go | 41 +++++++ pkg/utils/rebase_todo.go | 84 +++++++++++++ pkg/utils/rebase_todo_test.go | 178 ++++++++++++++++++++++++++++ 4 files changed, 331 insertions(+) diff --git a/pkg/app/daemon/daemon.go b/pkg/app/daemon/daemon.go index 8cb79eda0..3dbddcf2e 100644 --- a/pkg/app/daemon/daemon.go +++ b/pkg/app/daemon/daemon.go @@ -38,6 +38,7 @@ const ( DaemonKindDropMergeCommit DaemonKindMoveFixupCommitDown DaemonKindWriteRebaseTodo + DaemonKindMoveCommitTodos ) const ( @@ -60,6 +61,7 @@ func getInstruction() Instruction { DaemonKindMoveTodosDown: deserializeInstruction[*MoveTodosDownInstruction], DaemonKindInsertBreak: deserializeInstruction[*InsertBreakInstruction], DaemonKindWriteRebaseTodo: deserializeInstruction[*WriteRebaseTodoInstruction], + DaemonKindMoveCommitTodos: deserializeInstruction[*MoveCommitTodosInstruction], } return mapping[getDaemonKind()](jsonData) @@ -325,6 +327,32 @@ func (self *MoveTodosDownInstruction) run(log *logrus.Entry) error { }) } +type MoveCommitTodosInstruction struct { + Hashes []string + Destination utils.TodoMoveDestination +} + +func NewMoveCommitTodosInstruction(hashes []string, destination utils.TodoMoveDestination) Instruction { + return &MoveCommitTodosInstruction{ + Hashes: hashes, + Destination: destination, + } +} + +func (self *MoveCommitTodosInstruction) Kind() DaemonKind { + return DaemonKindMoveCommitTodos +} + +func (self *MoveCommitTodosInstruction) SerializedInstructions() string { + return serializeInstruction(self) +} + +func (self *MoveCommitTodosInstruction) run(log *logrus.Entry) error { + return handleInteractiveRebase(log, func(path string) error { + return utils.MoveCommitTodos(path, self.Hashes, self.Destination, getCommentChar()) + }) +} + type InsertBreakInstruction struct{} func NewInsertBreakInstruction() Instruction { diff --git a/pkg/commands/git_commands/rebase.go b/pkg/commands/git_commands/rebase.go index b0c9fe077..8c2a147b5 100644 --- a/pkg/commands/git_commands/rebase.go +++ b/pkg/commands/git_commands/rebase.go @@ -140,6 +140,47 @@ func (self *RebaseCommands) MoveCommits(commits []*models.Commit, startIdx int, }).Run() } +// MoveCommitsTo moves the commits from startIdx to endIdx so that they sit +// directly on top of the commit at destinationIdx, which must be outside of +// that range; if destinationIdx is len(commits), they go below the last +// commit. Branches that point at commits inside the range stay with them. +// +// Once the moved commits are taken out, some branches may point at the commit +// at destinationIdx: its own ones and, if it is the commit directly below the +// moved commits, the ones that pointed at the newest of them. Those listed in +// branchesAbove point at the newest moved commit afterwards, the others at the +// commit at destinationIdx. +func (self *RebaseCommands) MoveCommitsTo( + commits []*models.Commit, startIdx int, endIdx int, destinationIdx int, branchesAbove []string, +) error { + // The commit at destinationIdx needs to be part of the rebase only if some + // of the branches pointing at it are to move; otherwise, the moved commits + // can go first in the rebase todo. + baseIdx := destinationIdx + if len(branchesAbove) > 0 { + baseIdx++ + } + baseIdx = max(baseIdx, endIdx+1) + destination := utils.TodoMoveDestination{ + RefsAfter: lo.Map(branchesAbove, func(branch string, _ int) string { + return "refs/heads/" + branch + }), + } + if baseIdx != destinationIdx { + destination.AfterHash = commits[destinationIdx].Hash() + } + + hashes := lo.Map(commits[startIdx:endIdx+1], func(commit *models.Commit, _ int) string { + return commit.Hash() + }) + + return self.PrepareInteractiveRebaseCommand(PrepareInteractiveRebaseCommandOpts{ + baseHashOrRoot: getBaseHashOrRoot(commits, baseIdx), + instruction: daemon.NewMoveCommitTodosInstruction(hashes, destination), + overrideEditor: true, + }).Run() +} + func (self *RebaseCommands) InteractiveRebase(commits []*models.Commit, startIdx int, endIdx int, action todo.TodoCommand, flag string) error { baseIndex := endIdx + 1 if action == todo.Squash || action == todo.Fixup { diff --git a/pkg/utils/rebase_todo.go b/pkg/utils/rebase_todo.go index f6fe5cb32..8be54a242 100644 --- a/pkg/utils/rebase_todo.go +++ b/pkg/utils/rebase_todo.go @@ -264,6 +264,90 @@ func moveTodosUp(todos []todo.Todo, todosToMove []Todo, isInRebase bool) ([]todo return todos, nil } +// Where MoveCommitTodos puts the todos that it moves. +type TodoMoveDestination struct { + // The commit whose todo the moved todos are to follow. If empty, they go + // to the beginning, after any labels and resets. + AfterHash string + // Once the moved todos are taken out, there may be update-ref todos + // directly after the todo of AfterHash (or at the beginning, if AfterHash + // is empty). Those for the refs listed here go after the moved todos, so + // that git points these refs at the last of them. The other ones stay + // before the moved todos. + RefsAfter []string +} + +// MoveCommitTodos moves the todos of the given commits to the given +// destination. The update-ref todos between them move along, so that each +// commit stays on the branch that it was on. The commits must be contiguous +// in the todo file apart from these update-ref todos. +func MoveCommitTodos(fileName string, hashes []string, destination TodoMoveDestination, commentChar byte) error { + todos, err := ReadRebaseTodoFile(fileName, commentChar) + if err != nil { + return err + } + rearrangedTodos, err := moveCommitTodos(todos, hashes, destination) + if err != nil { + return err + } + return WriteRebaseTodoFile(fileName, rearrangedTodos, commentChar) +} + +func moveCommitTodos(todos []todo.Todo, hashes []string, destination TodoMoveDestination) ([]todo.Todo, error) { + indices := make([]int, 0, len(hashes)) + for _, hash := range hashes { + idx, ok := findTodo(todos, Todo{Hash: hash}) + if !ok { + // Should never happen + return nil, fmt.Errorf("Todo %s not found in git-rebase-todo", hash) + } + indices = append(indices, idx) + } + + start, end := slices.Min(indices), slices.Max(indices)+1 + isUpdateRefOrComment := func(t todo.Todo) bool { + return t.Command == todo.UpdateRef || t.Command == todo.Comment + } + commitCount := lo.CountBy(todos[start:end], func(t todo.Todo) bool { return t.Commit != "" }) + if commitCount != len(hashes) || lo.SomeBy(todos[start:end], func(t todo.Todo) bool { + return t.Commit == "" && !isUpdateRefOrComment(t) + }) { + return nil, errors.New("The commits to move are not contiguous in git-rebase-todo") + } + + movedTodos := todos[start:end] + otherTodos := slices.Concat(todos[:start], todos[end:]) + + var runStart int + if destination.AfterHash == "" { + var found bool + _, runStart, found = lo.FindIndexOf(otherTodos, func(t todo.Todo) bool { + return t.Commit != "" || t.Command == todo.UpdateRef + }) + if !found { + runStart = len(otherTodos) + } + } else { + afterIdx, ok := findTodo(otherTodos, Todo{Hash: destination.AfterHash}) + if !ok { + // Should never happen + return nil, fmt.Errorf("Todo %s not found in git-rebase-todo", destination.AfterHash) + } + runStart = afterIdx + 1 + } + runEnd := runStart + for runEnd < len(otherTodos) && isUpdateRefOrComment(otherTodos[runEnd]) { + runEnd++ + } + todosBefore, todosAfter := lo.FilterReject(otherTodos[runStart:runEnd], func(t todo.Todo, _ int) bool { + return t.Command != todo.UpdateRef || !slices.Contains(destination.RefsAfter, t.Ref) + }) + + return slices.Concat( + otherTodos[:runStart], todosBefore, movedTodos, todosAfter, otherTodos[runEnd:], + ), nil +} + func MoveFixupCommitDown(fileName string, originalHash string, fixupHash string, changeToFixup bool, commentChar byte) error { todos, err := ReadRebaseTodoFile(fileName, commentChar) if err != nil { diff --git a/pkg/utils/rebase_todo_test.go b/pkg/utils/rebase_todo_test.go index b032e4057..6aa6d4c4a 100644 --- a/pkg/utils/rebase_todo_test.go +++ b/pkg/utils/rebase_todo_test.go @@ -52,6 +52,184 @@ func TestMoveTodos(t *testing.T) { }) } +func TestMoveCommitTodos(t *testing.T) { + pick := func(hash string) todo.Todo { return todo.Todo{Command: todo.Pick, Commit: hash} } + updateRef := func(ref string) todo.Todo { return todo.Todo{Command: todo.UpdateRef, Ref: ref} } + + scenarios := []struct { + testName string + todos []todo.Todo + hashes []string + destination TodoMoveDestination + expectedErr string + expectedTodos []todo.Todo + }{ + { + testName: "move to the beginning", + todos: []todo.Todo{pick("a"), pick("b"), pick("c")}, + hashes: []string{"c"}, + destination: TodoMoveDestination{}, + expectedTodos: []todo.Todo{pick("c"), pick("a"), pick("b")}, + }, + { + testName: "move to the beginning, after labels and resets", + todos: []todo.Todo{ + {Command: todo.Label, Label: "onto"}, + {Command: todo.Reset, Label: "onto"}, + pick("a"), + pick("b"), + }, + hashes: []string{"b"}, + destination: TodoMoveDestination{}, + expectedTodos: []todo.Todo{ + {Command: todo.Label, Label: "onto"}, + {Command: todo.Reset, Label: "onto"}, + pick("b"), + pick("a"), + }, + }, + { + testName: "move towards the beginning", + todos: []todo.Todo{pick("a"), pick("b"), pick("c"), pick("d")}, + hashes: []string{"d"}, + destination: TodoMoveDestination{AfterHash: "a"}, + expectedTodos: []todo.Todo{pick("a"), pick("d"), pick("b"), pick("c")}, + }, + { + testName: "move towards the end", + todos: []todo.Todo{pick("a"), pick("b"), pick("c"), pick("d")}, + hashes: []string{"a"}, + destination: TodoMoveDestination{AfterHash: "c"}, + expectedTodos: []todo.Todo{pick("b"), pick("c"), pick("a"), pick("d")}, + }, + { + testName: "move several commits", + todos: []todo.Todo{pick("a"), pick("b"), pick("c"), pick("d")}, + hashes: []string{"c", "b"}, + destination: TodoMoveDestination{AfterHash: "d"}, + expectedTodos: []todo.Todo{pick("a"), pick("d"), pick("b"), pick("c")}, + }, + { + testName: "update-refs between the moved commits move along", + todos: []todo.Todo{pick("a"), pick("b"), updateRef("refs/heads/x"), pick("c"), pick("d")}, + hashes: []string{"c", "b"}, + destination: TodoMoveDestination{AfterHash: "d"}, + expectedTodos: []todo.Todo{pick("a"), pick("d"), pick("b"), updateRef("refs/heads/x"), pick("c")}, + }, + { + testName: "update-refs after the moved commits stay", + todos: []todo.Todo{pick("a"), pick("b"), updateRef("refs/heads/x"), pick("c")}, + hashes: []string{"b"}, + destination: TodoMoveDestination{}, + expectedTodos: []todo.Todo{pick("b"), pick("a"), updateRef("refs/heads/x"), pick("c")}, + }, + { + testName: "update-refs at the beginning stay before the moved commits", + todos: []todo.Todo{pick("a"), updateRef("refs/heads/x"), pick("b")}, + hashes: []string{"a"}, + destination: TodoMoveDestination{}, + expectedTodos: []todo.Todo{updateRef("refs/heads/x"), pick("a"), pick("b")}, + }, + { + testName: "update-refs at the beginning that are listed go after the moved commits", + todos: []todo.Todo{pick("a"), updateRef("refs/heads/x"), pick("b")}, + hashes: []string{"a"}, + destination: TodoMoveDestination{RefsAfter: []string{"refs/heads/x"}}, + expectedTodos: []todo.Todo{pick("a"), updateRef("refs/heads/x"), pick("b")}, + }, + { + testName: "update-refs of the destination stay before the moved commits", + todos: []todo.Todo{pick("a"), updateRef("refs/heads/x"), pick("b"), pick("c")}, + hashes: []string{"c"}, + destination: TodoMoveDestination{AfterHash: "a"}, + expectedTodos: []todo.Todo{pick("a"), updateRef("refs/heads/x"), pick("c"), pick("b")}, + }, + { + testName: "update-refs of the destination that are listed go after the moved commits", + todos: []todo.Todo{ + pick("a"), + updateRef("refs/heads/x"), + updateRef("refs/heads/y"), + updateRef("refs/heads/z"), + pick("b"), + }, + hashes: []string{"b"}, + destination: TodoMoveDestination{AfterHash: "a", RefsAfter: []string{"refs/heads/x", "refs/heads/z"}}, + expectedTodos: []todo.Todo{ + pick("a"), + updateRef("refs/heads/y"), + pick("b"), + updateRef("refs/heads/x"), + updateRef("refs/heads/z"), + }, + }, + { + testName: "update-refs after the moved commits join those of the destination", + todos: []todo.Todo{ + pick("a"), + updateRef("refs/heads/x"), + pick("b"), + updateRef("refs/heads/y"), + pick("c"), + }, + hashes: []string{"b"}, + destination: TodoMoveDestination{AfterHash: "a", RefsAfter: []string{"refs/heads/x", "refs/heads/y"}}, + expectedTodos: []todo.Todo{ + pick("a"), + pick("b"), + updateRef("refs/heads/x"), + updateRef("refs/heads/y"), + pick("c"), + }, + }, + { + testName: "commit not found", + todos: []todo.Todo{pick("a"), pick("b")}, + hashes: []string{"c"}, + destination: TodoMoveDestination{}, + expectedErr: "Todo c not found in git-rebase-todo", + }, + { + testName: "destination not found", + todos: []todo.Todo{pick("a"), pick("b")}, + hashes: []string{"b"}, + destination: TodoMoveDestination{AfterHash: "c"}, + expectedErr: "Todo c not found in git-rebase-todo", + }, + { + testName: "other commit between the moved commits", + todos: []todo.Todo{pick("a"), pick("b"), pick("c"), pick("d")}, + hashes: []string{"d", "b"}, + destination: TodoMoveDestination{}, + expectedErr: "The commits to move are not contiguous in git-rebase-todo", + }, + { + testName: "label between the moved commits", + todos: []todo.Todo{ + pick("a"), + pick("b"), + {Command: todo.Label, Label: "x"}, + pick("c"), + }, + hashes: []string{"c", "b"}, + destination: TodoMoveDestination{}, + expectedErr: "The commits to move are not contiguous in git-rebase-todo", + }, + } + + for _, s := range scenarios { + t.Run(s.testName, func(t *testing.T) { + actual, err := moveCommitTodos(s.todos, s.hashes, s.destination) + if s.expectedErr == "" { + assert.NoError(t, err) + assert.Equal(t, s.expectedTodos, actual) + } else { + assert.EqualError(t, err, s.expectedErr) + } + }) + } +} + func TestRebaseCommands_moveTodoDown(t *testing.T) { type scenario struct { testName string