@matheusbsbs / matheus-bagliano / commits / c6c2257930

builtin/history: introduce "fixup" subcommand

The newly introduced git-history(1) command provides functionality to easily edit commit history while also rebasing dependent branches. The functionality exposed by this command is still somewhat limited though. One common use case when editing commit history that is not yet covered is fixing up a specific commit. Introduce a new subcommand that allows the user to do exactly that by performing a three-way merge into the target's commit tree, using HEAD's tree as the merge base. The flow is thus essentially: $ echo changes >file $ git add file $ git history fixup HEAD~ Like with the other commands, this will automatically rebase dependent branches, as well. Unlike the other commands though: - The command does not work in a bare repository as it interacts with the index. - The command may run into merge conflicts. If so, the command will simply abort. Especially the second item limits the usefulness of this command a bit. But there are plans to introduce first-class conflicts into Git, which will help use cases like this one. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Patrick Steinhardt committed Apr 27, 2026 at 07:53 UTC c6c225793003ffb8b376c8994d44ca63bc04ac40
4 files changed +999 -6
Documentation/git-history.adoc
+76 -2
@@ -8,6 +8,7 @@ git-history - EXPERIMENTAL: Rewrite history
8 SYNOPSIS
9 --------
10 [synopsis]
11 +git history fixup <commit> [--dry-run] [--update-refs=(branches|head)] [--reedit-message] [--empty=(drop|keep|abort)]
12 git history reword <commit> [--dry-run] [--update-refs=(branches|head)]
13 git history split <commit> [--dry-run] [--update-refs=(branches|head)] [--] [<pathspec>...]
14
@@ -22,8 +23,9 @@ THIS COMMAND IS EXPERIMENTAL. THE BEHAVIOR MAY CHANGE.
23 This command is related to linkgit:git-rebase[1] in that both commands can be
24 used to rewrite history. There are a couple of major differences though:
25
25 -* linkgit:git-history[1] can work in a bare repository as it does not need to
26 - touch either the index or the worktree.
26 +* Most subcommands of linkgit:git-history[1] can work in a bare repository as
27 + they do not need to touch either the index or the worktree. The `fixup`
28 + subcommand is an exception to this, as it reads staged changes from the index.
29 * linkgit:git-history[1] does not execute any linkgit:githooks[5] at the
30 current point in time. This may change in the future.
31 * linkgit:git-history[1] by default updates all branches that are descendants
@@ -48,11 +50,28 @@ conflicts. This limitation is by design as history rewrites are not intended to
50 be stateful operations. The limitation can be lifted once (if) Git learns about
51 first-class conflicts.
52
53 +When using `fixup` with `--empty=drop`, dropping the root commit is not yet
54 +supported.
55 +
56 COMMANDS
57 --------
58
59 The following commands are available to rewrite history in different ways:
60
61 +`fixup <commit>`::
62 + Apply the currently staged changes to the specified commit. This is
63 + similar in nature to `git commit --fixup=<commit>` followed by `git
64 + rebase --autosquash <commit>~`. Changes are applied to the target
65 + commit by performing a three-way merge between the HEAD commit, the
66 + target commit and the tree generated from staged changes.
67 ++
68 +The commit message and authorship of the target commit are preserved by
69 +default, unless you specify `--reedit-message`.
70 ++
71 +If applying the staged changes would result in a conflict, the command
72 +aborts with an error. All branches that are descendants of the original
73 +commit are updated to point to the rewritten history.
74 +
75 `reword <commit>`::
76 Rewrite the commit message of the specified commit. All the other
77 details of this commit remain unchanged. This command will spawn an
@@ -87,6 +106,31 @@ OPTIONS
106 objects will be written into the repository, so applying these printed
107 ref updates is generally safe.
108
109 +`--reedit-message`::
110 + Open an editor to modify the target commit's message.
111 +
112 +`--empty=(drop|keep|abort)`::
113 + Control what happens when a commit becomes empty as a result of the
114 + fixup. This can happen in two situations:
115 ++
116 +--
117 +* The fixup target itself becomes empty because the staged changes exactly
118 + cancel out all changes introduced by that commit.
119 +
120 +* A descendant commit becomes empty during replay because it introduced the
121 + same change that was just fixed up into an ancestor.
122 +--
123 ++
124 +With `drop` (the default), empty commits are removed from the rewritten
125 +history. Descendants of a dropped target commit are replayed directly onto
126 +the target's parent. Note that dropping the root commit is not supported;
127 +see LIMITATIONS.
128 ++
129 +With `keep`, empty commits are retained in the rewritten history as-is.
130 ++
131 +With `abort`, the command stops with an error if any commit would become
132 +empty.
133 +
134 `--update-refs=(branches|head)`::
135 Control which references will be updated by the command, if any. With
136 `branches`, all local branches that point to commits which are
@@ -96,6 +140,36 @@ OPTIONS
140 EXAMPLES
141 --------
142
143 +Fixup a commit
144 +~~~~~~~~~~~~~~
145 +
146 +----------
147 +$ git log --oneline --stat
148 +abc1234 (HEAD -> main) third
149 + third.txt | 1 +
150 +def5678 second
151 + second.txt | 1 +
152 +ghi9012 first
153 + first.txt | 1 +
154 +
155 +$ echo "change" >>unrelated.txt
156 +$ git add unrelated.txt
157 +$ git history fixup ghi9012
158 +
159 +$ git log --oneline --stat
160 +jkl3456 (HEAD -> main) third
161 + third.txt | 1 +
162 +mno7890 second
163 + second.txt | 1 +
164 +pqr1234 first
165 + first.txt | 1 +
166 + unrelated.txt | 1 +
167 +----------
168 +
169 +The staged addition of `unrelated.txt` has been incorporated into the `first`
170 +commit. All descendant commits have been replayed on top of the rewritten
171 +history.
172 +
173 Split a commit
174 ~~~~~~~~~~~~~~
175
builtin/history.c
+242 -4
@@ -10,6 +10,7 @@
10 #include "gettext.h"
11 #include "hex.h"
12 #include "lockfile.h"
13 +#include "merge-ort.h"
14 #include "oidmap.h"
15 #include "parse-options.h"
16 #include "path.h"
@@ -23,6 +24,8 @@
24 #include "unpack-trees.h"
25 #include "wt-status.h"
26
27 +#define GIT_HISTORY_FIXUP_USAGE \
28 + N_("git history fixup <commit> [--dry-run] [--update-refs=(branches|head)] [--reedit-message] [--empty=(drop|keep|abort)]")
29 #define GIT_HISTORY_REWORD_USAGE \
30 N_("git history reword <commit> [--dry-run] [--update-refs=(branches|head)]")
31 #define GIT_HISTORY_SPLIT_USAGE \
@@ -335,10 +338,13 @@ static int handle_reference_updates(struct rev_info *revs,
338 struct commit *original,
339 struct commit *rewritten,
340 const char *reflog_msg,
338 - int dry_run)
341 + int dry_run,
342 + enum replay_empty_commit_action empty)
343 {
344 const struct name_decoration *decoration;
341 - struct replay_revisions_options opts = { 0 };
345 + struct replay_revisions_options opts = {
346 + .empty = empty,
347 + };
348 struct replay_result result = { 0 };
349 struct ref_transaction *transaction = NULL;
350 struct strbuf err = STRBUF_INIT;
@@ -434,6 +440,236 @@ out:
440 return ret;
441 }
442
443 +static int commit_became_empty(struct repository *repo,
444 + struct commit *original,
445 + struct tree *result)
446 +{
447 + struct commit *parent = original->parents ? original->parents->item : NULL;
448 + struct object_id parent_tree_oid;
449 +
450 + if (parent) {
451 + if (repo_parse_commit(repo, parent))
452 + return error(_("unable to parse parent of %s"),
453 + oid_to_hex(&original->object.oid));
454 +
455 + parent_tree_oid = repo_get_commit_tree(repo, parent)->object.oid;
456 + } else {
457 + oidcpy(&parent_tree_oid, repo->hash_algo->empty_tree);
458 + }
459 +
460 + return oideq(&result->object.oid, &parent_tree_oid);
461 +}
462 +
463 +static int parse_opt_empty(const struct option *opt, const char *arg, int unset)
464 +{
465 + enum replay_empty_commit_action *value = opt->value;
466 +
467 + BUG_ON_OPT_NEG(unset);
468 +
469 + if (!strcmp(arg, "drop"))
470 + *value = REPLAY_EMPTY_COMMIT_DROP;
471 + else if (!strcmp(arg, "keep"))
472 + *value = REPLAY_EMPTY_COMMIT_KEEP;
473 + else if (!strcmp(arg, "abort"))
474 + *value = REPLAY_EMPTY_COMMIT_ABORT;
475 + else
476 + die(_("unrecognized '--empty=' action '%s'; "
477 + "valid values are \"drop\", \"keep\", and \"abort\"."), arg);
478 +
479 + return 0;
480 +}
481 +
482 +static int cmd_history_fixup(int argc,
483 + const char **argv,
484 + const char *prefix,
485 + struct repository *repo)
486 +{
487 + const char * const usage[] = {
488 + GIT_HISTORY_FIXUP_USAGE,
489 + NULL,
490 + };
491 + enum replay_empty_commit_action empty = REPLAY_EMPTY_COMMIT_DROP;
492 + enum ref_action action = REF_ACTION_DEFAULT;
493 + enum commit_tree_flags flags = 0;
494 + int dry_run = 0;
495 + struct option options[] = {
496 + OPT_CALLBACK_F(0, "update-refs", &action, "(branches|head)",
497 + N_("control which refs should be updated"),
498 + PARSE_OPT_NONEG, parse_ref_action),
499 + OPT_BOOL('n', "dry-run", &dry_run,
500 + N_("perform a dry-run without updating any refs")),
501 + OPT_BIT(0, "reedit-message", &flags,
502 + N_("open an editor to modify the commit message"),
503 + COMMIT_TREE_EDIT_MESSAGE),
504 + OPT_CALLBACK_F(0, "empty", &empty, "(drop|keep|abort)",
505 + N_("how to handle commits that become empty"),
506 + PARSE_OPT_NONEG, parse_opt_empty),
507 + OPT_END(),
508 + };
509 + struct merge_result merge_result = { 0 };
510 + struct merge_options merge_opts = { 0 };
511 + struct strbuf reflog_msg = STRBUF_INIT;
512 + struct commit *head_commit, *original, *rewritten;
513 + struct tree *head_tree, *original_tree, *index_tree;
514 + struct rev_info revs = { 0 };
515 + bool skip_commit = false;
516 + int ret;
517 +
518 + argc = parse_options(argc, argv, prefix, options, usage, 0);
519 + if (argc != 1) {
520 + ret = error(_("command expects a single revision"));
521 + goto out;
522 + }
523 + repo_config(repo, git_default_config, NULL);
524 +
525 + if (action == REF_ACTION_DEFAULT)
526 + action = REF_ACTION_BRANCHES;
527 +
528 + if (is_bare_repository()) {
529 + ret = error(_("cannot run fixup in a bare repository"));
530 + goto out;
531 + }
532 +
533 + /* Resolve the original commit, which is the one we want to fix up. */
534 + original = lookup_commit_reference_by_name(argv[0]);
535 + if (!original) {
536 + ret = error(_("commit cannot be found: %s"), argv[0]);
537 + goto out;
538 + }
539 +
540 + /*
541 + * Resolve HEAD so we can use its tree as the merge base: the staged
542 + * changes are expressed as a diff from HEAD's tree to the index tree.
543 + */
544 + head_commit = lookup_commit_reference_by_name("HEAD");
545 + if (!head_commit) {
546 + ret = error(_("cannot look up HEAD"));
547 + goto out;
548 + }
549 +
550 + head_tree = repo_get_commit_tree(repo, head_commit);
551 + if (!head_tree) {
552 + ret = error(_("cannot get tree for HEAD"));
553 + goto out;
554 + }
555 +
556 + if (repo_read_index(repo) < 0) {
557 + ret = error(_("unable to read index"));
558 + goto out;
559 + }
560 +
561 + if (!repo_index_has_changes(repo, head_tree, NULL)) {
562 + ret = error(_("nothing to fixup: no staged changes"));
563 + goto out;
564 + }
565 +
566 + /*
567 + * Write the index as a tree object. This is the "theirs" side of the
568 + * three-way merge: it is HEAD's tree with the staged changes applied.
569 + */
570 + index_tree = write_in_core_index_as_tree(repo, repo->index);
571 + if (!index_tree) {
572 + ret = error(_("unable to write index as a tree"));
573 + goto out;
574 + }
575 +
576 + original_tree = repo_get_commit_tree(repo, original);
577 + if (!original_tree) {
578 + ret = error(_("cannot get tree for commit %s"), argv[0]);
579 + goto out;
580 + }
581 +
582 + /*
583 + * Perform the three-way merge to reapply changes in the index onto the
584 + * target commit. This is using basically the same logic as a
585 + * cherry-pick, where the base commit is our HEAD, ours is the original
586 + * tree and theirs is the index tree.
587 + */
588 + init_basic_merge_options(&merge_opts, repo);
589 + merge_opts.ancestor = "HEAD";
590 + merge_opts.branch1 = argv[0];
591 + merge_opts.branch2 = "staged";
592 + merge_incore_nonrecursive(&merge_opts, head_tree,
593 + original_tree, index_tree, &merge_result);
594 +
595 + if (merge_result.clean < 0) {
596 + ret = error(_("merge failed while applying fixup"));
597 + goto out;
598 + }
599 +
600 + if (!merge_result.clean) {
601 + ret = error(_("fixup would produce conflicts; aborting"));
602 + goto out;
603 + }
604 +
605 + ret = commit_became_empty(repo, original, merge_result.tree);
606 + if (ret < 0)
607 + goto out;
608 + if (ret > 0) {
609 + switch (empty) {
610 + case REPLAY_EMPTY_COMMIT_DROP:
611 + /*
612 + * Drop the target commit by replaying its descendants
613 + * directly onto its parent.
614 + */
615 + rewritten = original->parents ? original->parents->item : NULL;
616 +
617 + /*
618 + * TODO: we don't yet have the ability to drop root
619 + * commits, but there's ultimately no good reason for
620 + * this restriction to exist other than a technical
621 + * limitation.
622 + */
623 + if (!rewritten) {
624 + ret = error(_("cannot drop root commit %s: "
625 + "it has no parent to replay onto"),
626 + argv[0]);
627 + goto out;
628 + }
629 +
630 + skip_commit = true;
631 + break;
632 + case REPLAY_EMPTY_COMMIT_KEEP:
633 + /* Proceed and record the empty commit. */
634 + break;
635 + case REPLAY_EMPTY_COMMIT_ABORT:
636 + ret = error(_("fixup makes commit %s empty"), argv[0]);
637 + goto out;
638 + }
639 + }
640 +
641 + ret = setup_revwalk(repo, action, original, &revs);
642 + if (ret)
643 + goto out;
644 +
645 + if (!skip_commit) {
646 + ret = commit_tree_ext(repo, "fixup", original, original->parents,
647 + &original_tree->object.oid, &merge_result.tree->object.oid,
648 + &rewritten, flags);
649 + if (ret < 0) {
650 + ret = error(_("failed writing fixed-up commit"));
651 + goto out;
652 + }
653 + }
654 +
655 + strbuf_addf(&reflog_msg, "fixup: updating %s", argv[0]);
656 +
657 + ret = handle_reference_updates(&revs, action, original, rewritten,
658 + reflog_msg.buf, dry_run, empty);
659 + if (ret < 0) {
660 + ret = error(_("failed replaying descendants"));
661 + goto out;
662 + }
663 +
664 + ret = 0;
665 +
666 +out:
667 + merge_finalize(&merge_opts, &merge_result);
668 + strbuf_release(&reflog_msg);
669 + release_revisions(&revs);
670 + return ret;
671 +}
672 +
673 static int cmd_history_reword(int argc,
674 const char **argv,
675 const char *prefix,
@@ -487,7 +723,7 @@ static int cmd_history_reword(int argc,
723 strbuf_addf(&reflog_msg, "reword: updating %s", argv[0]);
724
725 ret = handle_reference_updates(&revs, action, original, rewritten,
490 - reflog_msg.buf, dry_run);
726 + reflog_msg.buf, dry_run, REPLAY_EMPTY_COMMIT_ABORT);
727 if (ret < 0) {
728 ret = error(_("failed replaying descendants"));
729 goto out;
@@ -724,7 +960,7 @@ static int cmd_history_split(int argc,
960 strbuf_addf(&reflog_msg, "split: updating %s", argv[0]);
961
962 ret = handle_reference_updates(&revs, action, original, rewritten,
727 - reflog_msg.buf, dry_run);
963 + reflog_msg.buf, dry_run, REPLAY_EMPTY_COMMIT_ABORT);
964 if (ret < 0) {
965 ret = error(_("failed replaying descendants"));
966 goto out;
@@ -745,12 +981,14 @@ int cmd_history(int argc,
981 struct repository *repo)
982 {
983 const char * const usage[] = {
984 + GIT_HISTORY_FIXUP_USAGE,
985 GIT_HISTORY_REWORD_USAGE,
986 GIT_HISTORY_SPLIT_USAGE,
987 NULL,
988 };
989 parse_opt_subcommand_fn *fn = NULL;
990 struct option options[] = {
991 + OPT_SUBCOMMAND("fixup", &fn, cmd_history_fixup),
992 OPT_SUBCOMMAND("reword", &fn, cmd_history_reword),
993 OPT_SUBCOMMAND("split", &fn, cmd_history_split),
994 OPT_END(),
t/meson.build
+1
@@ -397,6 +397,7 @@ integration_tests = [
397 't3450-history.sh',
398 't3451-history-reword.sh',
399 't3452-history-split.sh',
400 + 't3453-history-fixup.sh',
401 't3500-cherry.sh',
402 't3501-revert-cherry-pick.sh',
403 't3502-cherry-pick-merge.sh',
t/t3453-history-fixup.sh new
+680
@@ -0,0 +1,680 @@
1 +#!/bin/sh
2 +
3 +test_description='tests for git-history fixup subcommand'
4 +
5 +. ./test-lib.sh
6 +
7 +fixup_with_message () {
8 + cat >message &&
9 + write_script fake-editor.sh <<-\EOF &&
10 + cp message "$1"
11 + EOF
12 + test_set_editor "$(pwd)"/fake-editor.sh &&
13 + git history fixup --reedit-message "$@" &&
14 + rm fake-editor.sh message
15 +}
16 +
17 +expect_changes () {
18 + git log --format="%s" --numstat "$@" >actual.raw &&
19 + sed '/^$/d' <actual.raw >actual &&
20 + cat >expect &&
21 + test_cmp expect actual
22 +}
23 +
24 +test_expect_success 'errors on missing commit argument' '
25 + test_when_finished "rm -rf repo" &&
26 + git init repo &&
27 + (
28 + cd repo &&
29 + test_commit initial &&
30 + test_must_fail git history fixup 2>err &&
31 + test_grep "command expects a single revision" err
32 + )
33 +'
34 +
35 +test_expect_success 'errors on too many arguments' '
36 + test_when_finished "rm -rf repo" &&
37 + git init repo &&
38 + (
39 + cd repo &&
40 + test_commit initial &&
41 + test_must_fail git history fixup HEAD HEAD 2>err &&
42 + test_grep "command expects a single revision" err
43 + )
44 +'
45 +
46 +test_expect_success 'errors on unknown revision' '
47 + test_when_finished "rm -rf repo" &&
48 + git init repo &&
49 + (
50 + cd repo &&
51 + test_commit initial &&
52 + test_must_fail git history fixup does-not-exist 2>err &&
53 + test_grep "commit cannot be found: does-not-exist" err
54 + )
55 +'
56 +
57 +test_expect_success 'errors when nothing is staged' '
58 + test_when_finished "rm -rf repo" &&
59 + git init repo &&
60 + (
61 + cd repo &&
62 + test_commit initial &&
63 + test_must_fail git history fixup HEAD 2>err &&
64 + test_grep "nothing to fixup: no staged changes" err
65 + )
66 +'
67 +
68 +test_expect_success 'errors in a bare repository' '
69 + test_when_finished "rm -rf repo repo.git" &&
70 + git init repo &&
71 + test_commit -C repo initial &&
72 + git clone --bare repo repo.git &&
73 + test_must_fail git -C repo.git history fixup HEAD 2>err &&
74 + test_grep "cannot run fixup in a bare repository" err
75 +'
76 +
77 +test_expect_success 'errors with invalid --empty= value' '
78 + test_when_finished "rm -rf repo" &&
79 + git init repo &&
80 + test_must_fail git -C repo history fixup --empty=bogus HEAD 2>err &&
81 + test_grep "unrecognized.*--empty.*bogus" err
82 +'
83 +
84 +test_expect_success 'can fixup the tip commit' '
85 + test_when_finished "rm -rf repo" &&
86 + git init repo &&
87 + (
88 + cd repo &&
89 + test_commit initial &&
90 + echo content >file.txt &&
91 + git add file.txt &&
92 + git commit -m "add file" &&
93 +
94 + echo fix >>file.txt &&
95 + git add file.txt &&
96 +
97 + expect_changes <<-\EOF &&
98 + add file
99 + 1 0 file.txt
100 + initial
101 + 1 0 initial.t
102 + EOF
103 +
104 + git symbolic-ref HEAD >branch-expect &&
105 + git history fixup HEAD &&
106 + git symbolic-ref HEAD >branch-actual &&
107 + test_cmp branch-expect branch-actual &&
108 +
109 + expect_changes <<-\EOF &&
110 + add file
111 + 2 0 file.txt
112 + initial
113 + 1 0 initial.t
114 + EOF
115 +
116 + # Verify the fix is in the tip commit tree
117 + git show HEAD:file.txt >actual &&
118 + printf "content\nfix\n" >expect &&
119 + test_cmp expect actual &&
120 +
121 + git reflog >reflog &&
122 + test_grep "fixup: updating HEAD" reflog
123 + )
124 +'
125 +
126 +test_expect_success 'can fixup a commit in the middle of history' '
127 + test_when_finished "rm -rf repo" &&
128 + git init repo &&
129 + (
130 + cd repo &&
131 + test_commit first &&
132 + echo content >file.txt &&
133 + git add file.txt &&
134 + git commit -m "add file" &&
135 + test_commit third &&
136 +
137 + echo fix >>file.txt &&
138 + git add file.txt &&
139 +
140 + expect_changes <<-\EOF &&
141 + third
142 + 1 0 third.t
143 + add file
144 + 1 0 file.txt
145 + first
146 + 1 0 first.t
147 + EOF
148 +
149 + git history fixup HEAD~ &&
150 +
151 + expect_changes <<-\EOF &&
152 + third
153 + 1 0 third.t
154 + add file
155 + 2 0 file.txt
156 + first
157 + 1 0 first.t
158 + EOF
159 +
160 + # Verify the fix landed in the "add file" commit.
161 + git show HEAD~:file.txt >actual &&
162 + printf "content\nfix\n" >expect &&
163 + test_cmp expect actual &&
164 +
165 + # And verify that the replayed commit also has the change.
166 + git show HEAD:file.txt >actual &&
167 + printf "content\nfix\n" >expect &&
168 + test_cmp expect actual
169 + )
170 +'
171 +
172 +test_expect_success 'can fixup root commit' '
173 + test_when_finished "rm -rf repo" &&
174 + git init repo &&
175 + (
176 + cd repo &&
177 + echo initial >root.txt &&
178 + git add root.txt &&
179 + git commit -m "root" &&
180 + test_commit second &&
181 +
182 + expect_changes <<-\EOF &&
183 + second
184 + 1 0 second.t
185 + root
186 + 1 0 root.txt
187 + EOF
188 +
189 + echo fix >>root.txt &&
190 + git add root.txt &&
191 + git history fixup HEAD~ &&
192 +
193 + expect_changes <<-\EOF &&
194 + second
195 + 1 0 second.t
196 + root
197 + 2 0 root.txt
198 + EOF
199 +
200 + git show HEAD~:root.txt >actual &&
201 + printf "initial\nfix\n" >expect &&
202 + test_cmp expect actual
203 + )
204 +'
205 +
206 +test_expect_success 'preserves commit message and authorship' '
207 + test_when_finished "rm -rf repo" &&
208 + git init repo &&
209 + (
210 + cd repo &&
211 + test_commit initial &&
212 + echo content >file.txt &&
213 + git add file.txt &&
214 + git commit --author="Original <original@example.com>" -m "original message" &&
215 +
216 + echo fix >>file.txt &&
217 + git add file.txt &&
218 + git history fixup HEAD &&
219 +
220 + # Message preserved
221 + git log -1 --format="%s" >actual &&
222 + echo "original message" >expect &&
223 + test_cmp expect actual &&
224 +
225 + # Authorship preserved
226 + git log -1 --format="%an <%ae>" >actual &&
227 + echo "Original <original@example.com>" >expect &&
228 + test_cmp expect actual
229 + )
230 +'
231 +
232 +test_expect_success 'updates all descendant branches by default' '
233 + test_when_finished "rm -rf repo" &&
234 + git init repo --initial-branch=main &&
235 + (
236 + cd repo &&
237 + test_commit base &&
238 + git branch branch &&
239 + test_commit ours &&
240 + git switch branch &&
241 + test_commit theirs &&
242 + git switch main &&
243 +
244 + echo fix >fix.txt &&
245 + git add fix.txt &&
246 + git history fixup base &&
247 +
248 + expect_changes --branches <<-\EOF &&
249 + theirs
250 + 1 0 theirs.t
251 + ours
252 + 1 0 ours.t
253 + base
254 + 1 0 base.t
255 + 1 0 fix.txt
256 + EOF
257 +
258 + # Both branches should have the fix in the base
259 + git show main~:fix.txt >actual &&
260 + echo fix >expect &&
261 + test_cmp expect actual &&
262 + git show branch~:fix.txt >actual &&
263 + test_cmp expect actual
264 + )
265 +'
266 +
267 +test_expect_success 'can fixup commit on a different branch' '
268 + test_when_finished "rm -rf repo" &&
269 + git init repo &&
270 + (
271 + cd repo &&
272 + test_commit base &&
273 + git branch theirs &&
274 + test_commit ours &&
275 + git switch theirs &&
276 + test_commit theirs &&
277 +
278 + # Stage a change while on "theirs"
279 + echo fix >fix.txt &&
280 + git add fix.txt &&
281 +
282 + # Ensure that "ours" does not change, as it does not contain
283 + # the commit in question.
284 + git rev-parse ours >ours-before &&
285 + git history fixup theirs &&
286 + git rev-parse ours >ours-after &&
287 + test_cmp ours-before ours-after &&
288 +
289 + git show HEAD:fix.txt >actual &&
290 + echo fix >expect &&
291 + test_cmp expect actual
292 + )
293 +'
294 +
295 +test_expect_success '--dry-run prints ref updates without modifying repo' '
296 + test_when_finished "rm -rf repo" &&
297 + git init repo --initial-branch=main &&
298 + (
299 + cd repo &&
300 + test_commit base &&
301 + git branch branch &&
302 + test_commit main-tip &&
303 + git switch branch &&
304 + test_commit branch-tip &&
305 + git switch main &&
306 +
307 + echo fix >fix.txt &&
308 + git add fix.txt &&
309 +
310 + git refs list >refs-before &&
311 + git history fixup --dry-run base >updates &&
312 + git refs list >refs-after &&
313 + test_cmp refs-before refs-after &&
314 +
315 + test_grep "update refs/heads/main" updates &&
316 + test_grep "update refs/heads/branch" updates &&
317 +
318 + expect_changes --branches <<-\EOF &&
319 + branch-tip
320 + 1 0 branch-tip.t
321 + main-tip
322 + 1 0 main-tip.t
323 + base
324 + 1 0 base.t
325 + EOF
326 +
327 + git update-ref --stdin <updates &&
328 + expect_changes --branches <<-\EOF
329 + branch-tip
330 + 1 0 branch-tip.t
331 + main-tip
332 + 1 0 main-tip.t
333 + base
334 + 1 0 base.t
335 + 1 0 fix.txt
336 + EOF
337 + )
338 +'
339 +
340 +test_expect_success '--update-refs=head updates only HEAD' '
341 + test_when_finished "rm -rf repo" &&
342 + git init repo --initial-branch=main &&
343 + (
344 + cd repo &&
345 + test_commit base &&
346 + git branch branch &&
347 + test_commit main-tip &&
348 + git switch branch &&
349 + test_commit branch-tip &&
350 +
351 + echo fix >fix.txt &&
352 + git add fix.txt &&
353 +
354 + # Only HEAD (branch) should be updated
355 + git history fixup --update-refs=head base &&
356 +
357 + # The main branch should be unaffected.
358 + expect_changes main <<-\EOF &&
359 + main-tip
360 + 1 0 main-tip.t
361 + base
362 + 1 0 base.t
363 + EOF
364 +
365 + # But the currently checked out branch should be modified.
366 + expect_changes branch <<-\EOF
367 + branch-tip
368 + 1 0 branch-tip.t
369 + base
370 + 1 0 base.t
371 + 1 0 fix.txt
372 + EOF
373 + )
374 +'
375 +
376 +test_expect_success '--update-refs=head refuses to rewrite commits not in HEAD ancestry' '
377 + test_when_finished "rm -rf repo" &&
378 + git init repo --initial-branch=main &&
379 + (
380 + cd repo &&
381 + test_commit base &&
382 + git branch other &&
383 + test_commit main-tip &&
384 + git switch other &&
385 + test_commit other-tip &&
386 +
387 + echo fix >fix.txt &&
388 + git add fix.txt &&
389 +
390 + test_must_fail git history fixup --update-refs=head main-tip 2>err &&
391 + test_grep "rewritten commit must be an ancestor of HEAD" err
392 + )
393 +'
394 +
395 +test_expect_success 'aborts when fixup would produce conflicts' '
396 + test_when_finished "rm -rf repo" &&
397 + git init repo &&
398 + (
399 + cd repo &&
400 +
401 + echo "line one" >file.txt &&
402 + git add file.txt &&
403 + git commit -m "first" &&
404 +
405 + echo "line two" >file.txt &&
406 + git add file.txt &&
407 + git commit -m "second" &&
408 +
409 + echo "conflicting change" >file.txt &&
410 + git add file.txt &&
411 +
412 + git refs list >refs-before &&
413 + test_must_fail git history fixup HEAD~ 2>err &&
414 + test_grep "fixup would produce conflicts" err &&
415 + git refs list >refs-after &&
416 + test_cmp refs-before refs-after
417 + )
418 +'
419 +
420 +test_expect_success '--reedit-message opens editor for the commit message' '
421 + test_when_finished "rm -rf repo" &&
422 + git init repo &&
423 + (
424 + cd repo &&
425 + test_commit initial &&
426 + echo content >file.txt &&
427 + git add file.txt &&
428 + git commit -m "add file" &&
429 +
430 + echo fix >>file.txt &&
431 + git add file.txt &&
432 +
433 + fixup_with_message HEAD <<-\EOF &&
434 + add file with fix
435 + EOF
436 +
437 + expect_changes --branches <<-\EOF
438 + add file with fix
439 + 2 0 file.txt
440 + initial
441 + 1 0 initial.t
442 + EOF
443 + )
444 +'
445 +
446 +test_expect_success 'retains unstaged working tree changes after fixup' '
447 + test_when_finished "rm -rf repo" &&
448 + git init repo &&
449 + (
450 + cd repo &&
451 + touch a b &&
452 + git add . &&
453 + git commit -m "initial commit" &&
454 + echo staged >a &&
455 + echo unstaged >b &&
456 + git add a &&
457 + git history fixup HEAD &&
458 +
459 + # b is still modified in the worktree but not staged
460 + cat >expect <<-\EOF &&
461 + M b
462 + EOF
463 + git status --porcelain --untracked-files=no >actual &&
464 + test_cmp expect actual
465 + )
466 +'
467 +
468 +test_expect_success 'index is clean after fixup when target is HEAD' '
469 + test_when_finished "rm -rf repo" &&
470 + git init repo &&
471 + (
472 + cd repo &&
473 +
474 + test_commit initial &&
475 + echo fix >fix.txt &&
476 + git add fix.txt &&
477 + git history fixup HEAD &&
478 +
479 + git status --porcelain --untracked-files=no >actual &&
480 + test_must_be_empty actual
481 + )
482 +'
483 +
484 +test_expect_success 'index is unchanged on conflict' '
485 + test_when_finished "rm -rf repo" &&
486 + git init repo &&
487 + (
488 + cd repo &&
489 +
490 + echo base >file.txt &&
491 + git add file.txt &&
492 + git commit -m base &&
493 + echo change >file.txt &&
494 + git add file.txt &&
495 + git commit -m change &&
496 +
497 + echo conflict >file.txt &&
498 + git add file.txt &&
499 +
500 + git diff --cached >index-before &&
501 + test_must_fail git history fixup HEAD~ &&
502 + git diff --cached >index-after &&
503 + test_cmp index-before index-after
504 + )
505 +'
506 +
507 +test_expect_success '--empty=drop removes target commit and replays descendants onto its parent' '
508 + test_when_finished "rm -rf repo" &&
509 + git init repo --initial-branch=main &&
510 + (
511 + cd repo &&
512 +
513 + test_commit first &&
514 + test_commit second &&
515 + test_commit third &&
516 +
517 + git rm second.t &&
518 + git history fixup --empty=drop HEAD~ &&
519 +
520 + expect_changes <<-\EOF &&
521 + third
522 + 1 0 third.t
523 + first
524 + 1 0 first.t
525 + EOF
526 + test_must_fail git show HEAD:second.t
527 + )
528 +'
529 +
530 +test_expect_success '--empty=drop errors out when dropping the root commit' '
531 + test_when_finished "rm -rf repo" &&
532 + git init repo &&
533 + (
534 + cd repo &&
535 +
536 + test_commit first &&
537 + test_commit second &&
538 +
539 + git rm first.t &&
540 + test_must_fail git history fixup --empty=drop HEAD~ 2>err &&
541 + test_grep "cannot drop root commit" err
542 + )
543 +'
544 +
545 +test_expect_success '--empty=drop can drop the HEAD commit' '
546 + test_when_finished "rm -rf repo" &&
547 + git init repo &&
548 + (
549 + cd repo &&
550 +
551 + test_commit first &&
552 + test_commit second &&
553 +
554 + git rm second.t &&
555 + git history fixup --empty=drop HEAD &&
556 +
557 + expect_changes <<-\EOF
558 + first
559 + 1 0 first.t
560 + EOF
561 + )
562 +'
563 +
564 +test_expect_success '--empty=drop drops empty replayed commits' '
565 + test_when_finished "rm -rf repo" &&
566 + git init repo &&
567 + (
568 + cd repo &&
569 +
570 + touch base remove-me &&
571 + git add . &&
572 + git commit -m "base" &&
573 + git rm remove-me &&
574 + git commit -m "remove" &&
575 + touch reintroduce remove-me &&
576 + git add . &&
577 + git commit -m "reintroduce" &&
578 +
579 + git rm remove-me &&
580 + git history fixup --empty=drop HEAD~2 &&
581 +
582 + expect_changes <<-\EOF
583 + reintroduce
584 + 0 0 reintroduce
585 + 0 0 remove-me
586 + base
587 + 0 0 base
588 + EOF
589 + )
590 +'
591 +
592 +test_expect_success '--empty=keep keeps commit when fixup target becomes empty' '
593 + test_when_finished "rm -rf repo" &&
594 + git init repo &&
595 + (
596 + cd repo &&
597 +
598 + test_commit first &&
599 + test_commit second &&
600 + test_commit third &&
601 +
602 + git rm second.t &&
603 + git history fixup --empty=keep HEAD~ &&
604 +
605 + expect_changes <<-\EOF
606 + third
607 + 1 0 third.t
608 + second
609 + first
610 + 1 0 first.t
611 + EOF
612 + )
613 +'
614 +
615 +test_expect_success '--empty=keep keeps commit when replayed commit becomes empty' '
616 + test_when_finished "rm -rf repo" &&
617 + git init repo &&
618 + (
619 + cd repo &&
620 +
621 + touch base remove-me &&
622 + git add . &&
623 + git commit -m "base" &&
624 + git rm remove-me &&
625 + git commit -m "remove" &&
626 + touch reintroduce remove-me &&
627 + git add . &&
628 + git commit -m "reintroduce" &&
629 +
630 + git rm remove-me &&
631 + git history fixup --empty=keep HEAD~2 &&
632 +
633 + expect_changes <<-\EOF
634 + reintroduce
635 + 0 0 reintroduce
636 + 0 0 remove-me
637 + remove
638 + base
639 + 0 0 base
640 + EOF
641 + )
642 +'
643 +
644 +test_expect_success '--empty=abort errors out when fixup target becomes empty' '
645 + test_when_finished "rm -rf repo" &&
646 + git init repo &&
647 + (
648 + cd repo &&
649 +
650 + test_commit first &&
651 + test_commit second &&
652 +
653 + git rm first.t &&
654 + test_must_fail git history fixup --empty=abort HEAD~ 2>err &&
655 + test_grep "fixup makes commit.*empty" err
656 + )
657 +'
658 +
659 +test_expect_success '--empty=abort errors out when a descendant becomes empty during replay' '
660 + test_when_finished "rm -rf repo" &&
661 + git init repo --initial-branch=main &&
662 + (
663 + cd repo &&
664 +
665 + touch base remove-me &&
666 + git add . &&
667 + git commit -m "base" &&
668 + git rm remove-me &&
669 + git commit -m "remove" &&
670 + touch reintroduce remove-me &&
671 + git add . &&
672 + git commit -m "reintroduce" &&
673 +
674 + git rm remove-me &&
675 + test_must_fail git history fixup --empty=abort HEAD~2 2>err &&
676 + test_grep "became empty after replay" err
677 + )
678 +'
679 +
680 +test_done