Adds git history squash <revision-range> to fold a range of commits.
Changes in v9:
* Use the last amend! targeting the oldest folded commit as the default
squashed message. Ignore amend! markers targeting later commits while
selecting that replacement message.
* Improve tests.
Changes in v8:
* --reedit-message now builds the same editor template as git rebase -i
--autosquash: fixup!, squash! and amend! commits are grouped under the
commit they target instead of shown in commit order, and an amend!
replaces its target's message.
* A fixup!, squash! or amend! is refused only when its target is outside
the range, so several fixups for an in-range commit fold together. A
range that is entirely markers for one below-range target is combined
into a single commit, keeping the last amend! message.
* Merges inside the range are folded when the range has a single base, with
no dedicated opt-in flag, --ancestry-path ensures only commits descended
from the base are folded, and a range reaching more than one base is
rejected.
* Rev-list options are accepted and sanitized the way git replay does,
forcing the walk order back with a warning, which also fixes git history
squash -- --reverse slipping past the previous option check.
* Kept this as an explicit squash subcommand rather than making
--reedit-message the default or renaming the command.
Changes in v7:
* --reedit-message now builds the same editor template git rebase -i shows
for a squash (a combination of N commits banner with each folded message
under its own header) and follows autosquash for markers: a fixup!
message falls out (commented under a will be skipped header), while a
squash! or amend! keeps its body with only the marker subject commented
so its remark can be reworded in. Only the message text is affected,
every commit's changes are always folded in.
* Reuse git rebase -i's squash-message code: a preparatory sequencer:
commit extracts the banner, header and marker-comment helpers so both
rebase and git history squash build the identical template from one
source.
* Refuse a range whose oldest commit is a fixup!, squash! or amend!, since
the marker's target cannot be inside the range.
* Reorder the squash usage so dashed options come before <revision-range>,
and spell out HEAD instead of @ in the documentation and examples.
* Expand the squash commit message and documentation with this overview,
and scope the merge limitation so it no longer contradicts squash folding
a single-base interior merge.
Changes in v6:
* git history squash now accepts multiple revision arguments, read like the
arguments to git-rev-list, so a compound range such as @~3.. ^topic
works.
* The base to reparent onto is now the oldest in-range commit's parent; a
boundary other than that base means the range has more than one base and
is rejected. This also fixes the earlier overly-restrictive handling of
merges and side branches.
* A single-commit range (e.g. @^!) is rejected with "nothing to squash"
(this also covers the @^!-style example that previously succeeded
silently).
* Commit messages reworded: the squash commit now gives an overview of
fixup!/squash!/amend! handling, rewording, merge-parent and ref behavior.
Changes in v5:
* The range walk now uses --ancestry-path, so only commits descended from
the base are folded; a single revision such as HEAD or HEAD~1 is now
rejected as "not a <base>..<tip> range" rather than treated as a squash
down to the root.
* This adopts the --ancestry-path suggestion; the multi-base rejection is
unchanged, so a side branch that forked before the base and merged in is
still refused.
* Added tests covering more merge topologies: two interior merges, a nested
merge, an octopus merge, an octopus arm forked before the base, a merge
among the descendants replayed above the range, and a ref pointing at an
interior merge commit.
Changes in v4:
* git history squash now detects when another ref points at a commit inside
the range being folded and refuses, with an advice.historyUpdateRefs hint
to use --update-refs=head.
* A merge inside the range is folded fine as long as the range has a single
base; a range with merge commit at the tip or base also folds correctly.
Only a range with more than one base is rejected.
Changes in v3:
* Moved the feature out of git rebase and into a new git history squash
<revision-range> subcommand, per the list discussion. git rebase --squash
is dropped.
* Takes an arbitrary range (git history squash @~3.., git history squash
@~5..@~2), folding it into the oldest commit and replaying any
descendants on top.
* Implemented as a single tree operation rather than picking each commit,
so there are no repeated conflict stops (addresses Phillip's efficiency
point).
* A merge inside the range is folded fine, only a range with more than one
base is rejected.
* --reedit-message seeds the editor with every folded-in message, not just
the oldest.
Harald Nordgren (5):
history: extract helper for a commit's parent tree
history: give commit_tree_ext a message template
history: add squash subcommand to fold a range
sequencer: share the squash message marker helpers and flags
history: re-edit a squash with every message
Documentation/config/advice.adoc | 4 +
Documentation/git-history.adoc | 57 ++-
advice.c | 1 +
advice.h | 1 +
builtin/history.c | 550 ++++++++++++++++++++--
sequencer.c | 70 +--
sequencer.h | 30 ++
t/meson.build | 1 +
t/t3455-history-squash.sh | 766 +++++++++++++++++++++++++++++++
9 files changed, 1408 insertions(+), 72 deletions(-)
create mode 100755 t/t3455-history-squash.sh
base-commit: 55526a18268bbc1ddaf8a6b7850c33d984eac9e9
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2337%2FHaraldNordgren%2Frebase-fixup-fold-v9
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2337/HaraldNordgren/rebase-fixup-fold-v9
Pull-Request: https://github.com/git/git/pull/2337
Range-diff vs v8:
1: ba77752282 = 1: 352c818c29 history: extract helper for a commit's parent tree
2: 50f3572887 = 2: e06e49095b history: give commit_tree_ext a message template
3: 2d81a40a05 ! 3: ead974c317 history: add squash subcommand to fold a range
@@ Commit message
Add "git history squash <revision-range>" to do this directly. It folds
every commit in the range into the oldest one, keeping that commit's
- message and authorship and taking the tree of the newest commit, then
- replays the commits above the range on top. The squashed message comes
- from the oldest commit, or from an editor with --reedit-message. A
- fixup!, squash! or amend! commit is refused unless the commit it targets
- is also in the range, so the fold does not silently absorb a marker meant
- for a commit outside it. The check runs the range through
- todo_list_rearrange_squash(), which leaves such a marker as a plain pick.
- Markers whose target is in the range fold in as usual. As an exception, a
- range made up entirely of markers for one target is combined anyway,
- taking its message from the last amend! if there is one, so a batch of
- fixups for the same commit can be collapsed.
+ authorship and taking the tree of the newest commit, then replays the
+ commits above the range on top. The squashed message comes from the
+ oldest commit by default, or from the body of the last amend! commit
+ targeting it. An editor opens with the selected message when
+ --reedit-message is given. A fixup!, squash! or amend! commit is refused
+ unless the commit it targets is also in the range, so the fold does not
+ silently absorb a marker meant for a commit outside it. The check runs
+ the range through todo_list_rearrange_squash(), which leaves such a
+ marker as a plain pick. Markers whose target is in the range fold in as
+ usual. As an exception, a range made up entirely of markers for one
+ target is combined anyway, taking its message from the last amend! if
+ there is one, so a batch of fixups for the same commit can be collapsed.
The range is read like the arguments to "git rev-list", so several
revisions such as "HEAD~3..HEAD ^topic" may be given, and rev-list
@@ Documentation/git-history.adoc: linkgit:gitglossary[7].
+`squash <revision-range>`::
+ Fold all commits in _<revision-range>_ into the oldest commit of that
-+ range. The resulting commit keeps the oldest commit's message and
-+ authorship and takes the tree of the range's newest commit, so the
-+ whole range collapses into a single commit. Commits above the range
-+ are replayed on top of the result.
++ range. The resulting commit keeps the oldest commit's authorship and
++ takes the tree of the range's newest commit, so the whole range
++ collapses into a single commit. Commits above the range are replayed
++ on top of the result.
++
+The range is given in the usual `<base>..<tip>` form, where _<base>_ is
+the commit just below the oldest commit to squash. For example, `git
@@ Documentation/git-history.adoc: linkgit:gitglossary[7].
+already on `topic`. Rev-list options may also be given, but any that would
+change how the range is walked are overridden with a warning.
++
-+The oldest commit's message and authorship are preserved by default,
-+unless you specify `--reedit-message`. A merge commit inside the range is
-+folded like any other, but the range must have a single base, so a range
-+that reaches more than one entry point (for example a side branch that
-+forked before the range and was later merged into it) is rejected.
++The oldest commit's message is preserved by default, except that an `amend!`
++commit targeting it replaces its message. Specify `--reedit-message` to edit
++the resulting message. A merge commit inside the range is folded like any
++other, but the range must have a single base, so a range that reaches more
++than one entry point (for example a side branch that forked before the range
++and was later merged into it) is rejected.
++
+A `fixup!`, `squash!`, or `amend!` commit is refused unless the commit it
+targets is also in the range, so the fold does not silently absorb a
-+marker meant for a commit outside it. As an exception, a range made up
-+entirely of markers for one target is combined into a single commit,
-+keeping the last `amend!` message if there is one.
++marker meant for a commit outside it. The body after an `amend!` subject
++replaces the oldest commit's message when the marker targets that commit. As
++an exception, a range made up entirely of markers for one target is combined
++into a single commit, keeping the last `amend!` message if there is one.
++
+A branch or tag that points at a commit inside the range would be left
+dangling once those commits are folded away, so with the default
@@ builtin/history.c: out:
+ struct commit *base,
+ struct commit *tip,
+ struct commit *oldest,
-+ struct commit **msg_source)
++ struct commit **msg_source,
++ struct commit **amend_source)
+{
+ struct todo_list todo = TODO_LIST_INIT;
+ struct replay_opts opts = REPLAY_OPTS_INIT;
@@ builtin/history.c: out:
+ struct strvec args = STRVEC_INIT;
+ char *dangling_subject = NULL, *dangling_target = NULL;
+ bool mixed_target = false, all_fixups_one_target;
++ bool past_oldest_group = false;
+ int i, ret, nr_dangling = 0;
+
+ *msg_source = oldest;
++ *amend_source = NULL;
+
+ repo_init_revisions(repo, &revs, NULL);
+ strvec_push(&args, "ignored");
@@ builtin/history.c: out:
+ char *subject;
+ size_t sublen;
+
-+ if (todo.items[i].command != TODO_PICK)
-+ continue;
+ message = repo_logmsg_reencode(repo, todo.items[i].commit,
+ NULL, NULL);
+ sublen = find_commit_subject(message, &subject_start);
++
++ if (todo.items[i].command != TODO_PICK) {
++ if (!past_oldest_group &&
++ starts_with(subject_start, "amend! "))
++ *amend_source = todo.items[i].commit;
++ repo_unuse_commit_buffer(repo, todo.items[i].commit, message);
++ continue;
++ }
++ if (i)
++ past_oldest_group = true;
++
+ subject = xmemdupz(subject_start, sublen);
+ target = autosquash_target(subject);
+ if (target != subject) {
@@ builtin/history.c: out:
+ OPT_END(),
+ };
+ struct strbuf reflog_msg = STRBUF_INIT;
++ struct strbuf message = STRBUF_INIT;
+ struct oidset interior = OIDSET_INIT;
-+ struct commit *base, *oldest, *tip, *rewritten, *msg_source;
++ struct commit *base, *oldest, *tip, *rewritten, *msg_source,
++ *amend_source;
+ const struct object_id *base_tree_oid, *tip_tree_oid;
++ const char *message_template = NULL;
+ struct commit_list *parents = NULL;
+ struct rev_info revs = { 0 };
+ int ret;
@@ builtin/history.c: out:
+ if (ret < 0)
+ goto out;
+
-+ ret = reject_dangling_fixups(repo, base, tip, oldest, &msg_source);
++ ret = reject_dangling_fixups(repo, base, tip, oldest, &msg_source,
++ &amend_source);
+ if (ret < 0)
+ goto out;
++ if (amend_source) {
++ const char *amend_message, *body;
++
++ amend_message = repo_logmsg_reencode(repo, amend_source,
++ NULL, NULL);
++ find_commit_subject(amend_message, &body);
++ body = skip_blank_lines(body + commit_subject_length(body));
++ strbuf_addstr(&message, body);
++ message_template = message.buf;
++ repo_unuse_commit_buffer(repo, amend_source, amend_message);
++ }
+
+ if (action == REF_ACTION_BRANCHES) {
+ struct interior_ref_cb cb = { .interior = &interior };
@@ builtin/history.c: out:
+ tip_tree_oid = &repo_get_commit_tree(repo, tip)->object.oid;
+ commit_list_append(base, &parents);
+
-+ ret = commit_tree_ext(repo, "squash", msg_source, NULL, parents,
++ ret = commit_tree_ext(repo, "squash", msg_source, message_template,
++ parents,
+ base_tree_oid, tip_tree_oid, &rewritten, flags);
+ if (ret < 0) {
+ ret = error(_("failed writing squashed commit"));
@@ builtin/history.c: out:
+
+out:
+ strbuf_release(&reflog_msg);
++ strbuf_release(&message);
+ oidset_clear(&interior);
+ commit_list_free(parents);
+ release_revisions(&revs);
@@ t/t3455-history-squash.sh (new)
+
+. ./test-lib.sh
+
++stage_file () {
++ printf "%s\n" "$1" >file &&
++ git add file
++}
++
++commit_with_message () {
++ printf "%b" "$1" >msg &&
++ git commit --allow-empty -qF msg
++}
++
++check_commit_count () {
++ git rev-list --count "$1" >actual &&
++ echo "$2" >expect &&
++ test_cmp expect actual
++}
++
++check_log_subjects () {
++ git log --format="%s" "$1" >actual &&
++ cat >expect &&
++ test_cmp expect actual
++}
++
++check_log_messages () {
++ git log --format="%B" "$1" >actual &&
++ cat >expect &&
++ test_cmp expect actual
++}
++
+test_expect_success 'setup linear history touching two files' '
+ test_commit base file a &&
+ git tag start &&
@@ t/t3455-history-squash.sh (new)
+
+ git history squash start..HEAD ^keep &&
+
-+ git log --format="%s" start..HEAD >actual &&
-+ cat >expect <<-\EOF &&
++ check_log_subjects start..HEAD <<-\EOF &&
+ two
+ one
+ EOF
-+ test_cmp expect actual &&
+ test_cmp_rev keep HEAD~1 &&
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
+
@@ t/t3455-history-squash.sh (new)
+
+ git history squash start..off-history &&
+
-+ git rev-list --count start..off-history >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
++ check_commit_count start..off-history 1 &&
+ test_cmp_rev "$head_before" HEAD &&
+
+ git branch -D off-history
@@ t/t3455-history-squash.sh (new)
+ git history squash start.. &&
+
+ test "$predicted" = "$(git rev-parse HEAD)" &&
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
++ check_commit_count start..HEAD 1 &&
+ test_cmp_rev start HEAD^ &&
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
-+ git log --format="%s" -1 >subject &&
-+ echo one >expect &&
-+ test_cmp expect subject &&
++ check_log_subjects -1 <<-\EOF &&
++ one
++ EOF
+ git reflog >reflog &&
+ test_grep "squash: updating" reflog
+'
@@ t/t3455-history-squash.sh (new)
+
+ git history squash start..@~1 &&
+
-+ git log --format="%s" start..HEAD >actual &&
-+ cat >expect <<-\EOF &&
++ check_log_subjects start..HEAD <<-\EOF &&
+ three
+ one
+ EOF
-+ test_cmp expect actual &&
+
+ test_cmp_rev start HEAD~2 &&
+ test "$final_tree" = "$(git rev-parse HEAD^{tree})"
@@ t/t3455-history-squash.sh (new)
+
+ git history squash "$root.." &&
+
-+ git rev-list --count "$root..HEAD" >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
++ check_commit_count "$root..HEAD" 1 &&
+ test_cmp_rev "$root" HEAD^ &&
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})"
+'
@@ t/t3455-history-squash.sh (new)
+
+ git history squash start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
-+ git log --format="%s" -1 >actual &&
-+ echo target >expect &&
-+ test_cmp expect actual
++ check_commit_count start..HEAD 1 &&
++ check_log_subjects -1 <<-\EOF
++ target
++ EOF
+'
+
+test_expect_success 'refuses a below-range fixup! after an in-range commit' '
@@ t/t3455-history-squash.sh (new)
+
+test_expect_success 'combines a run of fixups for one commit below the range' '
+ git reset --hard start &&
-+ echo b >file && git add file && git commit -m "fixup! base" &&
-+ echo c >file && git add file && git commit -m "fixup! base" &&
++ stage_file b && git commit -m "fixup! base" &&
++ stage_file c && git commit -m "fixup! base" &&
+
+ git history squash start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
-+ git log --format="%s" -1 >actual &&
-+ echo "fixup! base" >expect &&
-+ test_cmp expect actual
++ check_commit_count start..HEAD 1 &&
++ check_log_subjects -1 <<-\EOF
++ fixup! base
++ EOF
+'
+
+test_expect_success 'combining below-range fixups keeps the last amend! message' '
+ git reset --hard start &&
-+ echo b >file && git add file && git commit -m "fixup! base" &&
-+ printf "amend! base\n\namended body\n" >msg &&
-+ echo c >file && git add file && git commit -qF msg &&
++ stage_file b && git commit -m "fixup! base" &&
++ stage_file c &&
++ commit_with_message "amend! base\n\namended body\n" &&
+
+ git history squash start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
-+ git log --format="%s" -1 >actual &&
-+ echo "amend! base" >expect &&
-+ test_cmp expect actual &&
-+ git log --format="%b" -1 >body &&
-+ test_grep "amended body" body
++ check_commit_count start..HEAD 1 &&
++ check_log_messages -1 <<-\EOF
++ amend! base
++
++ amended body
++
++ EOF
+'
+
+test_expect_success 'refuses fixups for two different commits below the range' '
+ git reset --hard start &&
-+ echo b >file && git add file && git commit -m "fixup! aaa" &&
-+ echo c >file && git add file && git commit -m "fixup! bbb" &&
++ stage_file b && git commit -m "fixup! aaa" &&
++ stage_file c && git commit -m "fixup! bbb" &&
+ head_before=$(git rev-parse HEAD) &&
+
+ test_must_fail git history squash start.. 2>err &&
@@ t/t3455-history-squash.sh (new)
+ test_cmp_rev "$head_before" HEAD
+'
+
-+test_expect_success 'keeps the oldest message for in-range squash! and amend!' '
++test_expect_success 'the last amend! for the oldest commit replaces its message' '
+ git reset --hard start &&
+ test_commit --no-tag marker-oldest file b &&
+ git commit --allow-empty -m "squash! marker-oldest" &&
-+ git commit --allow-empty -m "amend! marker-oldest" &&
-+ test_commit --no-tag marker-newest file c &&
++ commit_with_message "amend! marker-oldest\n\nearlier message\n" &&
++ commit_with_message \
++ "amend! marker-oldest\n\namended subject\n\namended body\n" &&
++ test_commit --no-tag marker-later file c &&
++ commit_with_message "amend! marker-later\n\nwrong message\n" &&
+
+ git history squash start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
-+ git log --format="%s" -1 >actual &&
-+ echo marker-oldest >expect &&
-+ test_cmp expect actual
++ check_commit_count start..HEAD 1 &&
++ check_log_messages -1 <<-\EOF
++ amended subject
++
++ amended body
++
++ EOF
+'
+
+test_expect_success 'preserves authorship of the oldest commit' '
@@ t/t3455-history-squash.sh (new)
+
+ git history squash --update-refs=head start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
++ check_commit_count start..HEAD 1 &&
+ test_cmp_rev "$other_before" other
+'
+
@@ t/t3455-history-squash.sh (new)
+
+ git history squash --update-refs=head start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
++ check_commit_count start..HEAD 1 &&
+ test_cmp_rev "$mid_before" mid &&
+
+ git branch -D mid
@@ t/t3455-history-squash.sh (new)
+
+ git history squash start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
-+ git log --format="%s" -1 >subject &&
-+ echo before-side >expect &&
-+ test_cmp expect subject &&
++ check_commit_count start..HEAD 1 &&
++ check_log_subjects -1 <<-\EOF &&
++ before-side
++ EOF
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
+ test_path_is_file inner
+'
@@ t/t3455-history-squash.sh (new)
+
+ git history squash start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
++ check_commit_count start..HEAD 1 &&
+ test_cmp_rev start HEAD^ &&
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
+ test_path_is_file side
@@ t/t3455-history-squash.sh (new)
+
+ git history squash start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
++ check_commit_count start..HEAD 1 &&
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
+ test_path_is_file side
+'
@@ t/t3455-history-squash.sh (new)
+
+ git history squash "$base.." &&
+
-+ git rev-list --count "$base..HEAD" >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
++ check_commit_count "$base..HEAD" 1 &&
+ test_cmp_rev "$base" HEAD^ &&
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})"
+'
@@ t/t3455-history-squash.sh (new)
+
+ git history squash start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
++ check_commit_count start..HEAD 1 &&
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
+ test_path_is_file s1 &&
+ test_path_is_file s2
@@ t/t3455-history-squash.sh (new)
+
+ git history squash start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
++ check_commit_count start..HEAD 1 &&
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
+ test_path_is_file outer &&
+ test_path_is_file inner
@@ t/t3455-history-squash.sh (new)
+
+ git history squash start.. &&
+
-+ git rev-list --count start..HEAD >count &&
-+ echo 1 >expect &&
-+ test_cmp expect count &&
++ check_commit_count start..HEAD 1 &&
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
+ test_path_is_file o1 &&
+ test_path_is_file o2
4: 0a735117ad = 4: 08915cee51 sequencer: share the squash message marker helpers and flags
5: baf7e6f0a6 ! 5: fb76afe31c history: re-edit a squash with every message
@@ Metadata
## Commit message ##
history: re-edit a squash with every message
- By default "git history squash" reuses the oldest commit's message.
- When --reedit-message is given it only reopened that one message, so the
+ By default "git history squash" reuses the oldest commit's message, or
+ the replacement body from an amend! commit targeting it. When
+ --reedit-message is given it only reopened that selected message, so the
messages of the other commits in the range were lost.
Gather the message of every commit in the range and build the same editor
@@ Commit message
Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
## Documentation/git-history.adoc ##
-@@ Documentation/git-history.adoc: given, for example `HEAD~3..HEAD ^topic` to additionally exclude what is
- already on `topic`. Rev-list options may also be given, but any that would
+@@ Documentation/git-history.adoc: already on `topic`. Rev-list options may also be given, but any that would
change how the range is walked are overridden with a warning.
+
--The oldest commit's message and authorship are preserved by default,
--unless you specify `--reedit-message`. A merge commit inside the range is
-+The oldest commit's message and authorship are preserved by default. With
-+`--reedit-message`, an editor opens pre-filled with the messages of all the
-+folded commits so you can combine them. A merge commit inside the range is
- folded like any other, but the range must have a single base, so a range
- that reaches more than one entry point (for example a side branch that
- forked before the range and was later merged into it) is rejected.
-@@ Documentation/git-history.adoc: A `fixup!`, `squash!`, or `amend!` commit is refused unless the commit it
+ The oldest commit's message is preserved by default, except that an `amend!`
+-commit targeting it replaces its message. Specify `--reedit-message` to edit
+-the resulting message. A merge commit inside the range is folded like any
+-other, but the range must have a single base, so a range that reaches more
+-than one entry point (for example a side branch that forked before the range
+-and was later merged into it) is rejected.
++commit targeting it replaces its message. With `--reedit-message`, an editor
++opens pre-filled with the messages of all the folded commits so you can
++combine them. A merge commit inside the range is folded like any other, but
++the range must have a single base, so a range that reaches more than one entry
++point (for example a side branch that forked before the range and was later
++merged into it) is rejected.
+ +
+ A `fixup!`, `squash!`, or `amend!` commit is refused unless the commit it
targets is also in the range, so the fold does not silently absorb a
- marker meant for a commit outside it. As an exception, a range made up
- entirely of markers for one target is combined into a single commit,
--keeping the last `amend!` message if there is one.
-+keeping the last `amend!` message if there is one. The changes from every
-+commit in the range are always folded in. Only the message text differs.
+@@ Documentation/git-history.adoc: marker meant for a commit outside it. The body after an `amend!` subject
+ replaces the oldest commit's message when the marker targets that commit. As
+ an exception, a range made up entirely of markers for one target is combined
+ into a single commit, keeping the last `amend!` message if there is one.
++The changes from every commit in the range are always folded in. Only the
++message text differs.
+With `--reedit-message` the template mirrors `git rebase -i --autosquash`:
+each `fixup!`, `squash!`, or `amend!` is grouped under the commit it
+targets rather than shown in commit order. A `fixup!` message is dropped
@@ builtin/history.c: static int find_interior_ref(const struct reference *ref, voi
static int cmd_history_squash(int argc,
const char **argv,
const char *prefix,
-@@ builtin/history.c: static int cmd_history_squash(int argc,
- OPT_END(),
- };
- struct strbuf reflog_msg = STRBUF_INIT;
-+ struct strbuf message = STRBUF_INIT;
- struct oidset interior = OIDSET_INIT;
- struct commit *base, *oldest, *tip, *rewritten, *msg_source;
- const struct object_id *base_tree_oid, *tip_tree_oid;
@@ builtin/history.c: static int cmd_history_squash(int argc,
}
}
+ if (flags & COMMIT_TREE_EDIT_MESSAGE) {
++ strbuf_reset(&message);
+ ret = build_squash_message(repo, base, tip, &message);
+ if (ret < 0)
+ goto out;
++ message_template = message.buf;
+ }
+
ret = setup_revwalk(repo, action, tip, &revs);
if (ret < 0)
goto out;
-@@ builtin/history.c: static int cmd_history_squash(int argc,
- tip_tree_oid = &repo_get_commit_tree(repo, tip)->object.oid;
- commit_list_append(base, &parents);
-
-- ret = commit_tree_ext(repo, "squash", msg_source, NULL, parents,
-+ ret = commit_tree_ext(repo, "squash", msg_source,
-+ message.len ? message.buf : NULL, parents,
- base_tree_oid, tip_tree_oid, &rewritten, flags);
- if (ret < 0) {
- ret = error(_("failed writing squashed commit"));
-@@ builtin/history.c: static int cmd_history_squash(int argc,
-
- out:
- strbuf_release(&reflog_msg);
-+ strbuf_release(&message);
- oidset_clear(&interior);
- commit_list_free(parents);
- release_revisions(&revs);
## t/t3455-history-squash.sh ##
@@ t/t3455-history-squash.sh: test_expect_success 'preserves authorship of the oldest commit' '
@@ t/t3455-history-squash.sh: test_expect_success 'preserves authorship of the olde
+test_expect_success '--reedit-message offers every folded-in message' '
+ git reset --hard start &&
-+ echo b >file &&
-+ git add file &&
++ stage_file b &&
+ git commit -m "re-one subject" -m "re-one body line" &&
+ test_commit --no-tag re-two file c &&
+ test_commit re-three file d &&
@@ t/t3455-history-squash.sh: test_expect_success 'preserves authorship of the olde
+ #
+ EOF
+ test_cmp expect edited &&
-+ echo combined >expect &&
-+ git log --format="%s" -1 >actual &&
-+ test_cmp expect actual
++ check_log_subjects -1 <<-\EOF
++ combined
++ EOF
+'
+
+test_expect_success '--reedit-message handles fixup!, squash! and amend! like rebase' '
+ git reset --hard start &&
+ test_commit --no-tag mark-base file b &&
-+ printf "fixup! mark-base\n\nfixup body\n" >msg &&
-+ echo c >file &&
-+ git add file &&
-+ git commit -qF msg &&
-+ printf "squash! mark-base\n\nsquash remark\n" >msg &&
-+ echo d >file &&
-+ git add file &&
-+ git commit -qF msg &&
-+ printf "amend! mark-base\n\namended message\n" >msg &&
-+ echo e >file &&
-+ git add file &&
-+ git commit -qF msg &&
++ stage_file c &&
++ commit_with_message "fixup! mark-base\n\nfixup body\n" &&
++ stage_file d &&
++ commit_with_message "squash! mark-base\n\nsquash remark\n" &&
++ stage_file e &&
++ commit_with_message "amend! mark-base\n\namended message\n" &&
+
+ write_script editor <<-\EOF &&
+ cat "$1" >edited
@@ t/t3455-history-squash.sh: test_expect_success 'preserves authorship of the olde
+ #
+ EOF
+ test_cmp expect edited &&
-+ git log -1 --format="%B" >final &&
-+ test_grep ! "fixup body" final &&
-+ test_grep "squash remark" final &&
-+ test_grep "amended message" final
++ check_log_messages -1 <<-\EOF
++ mark-base
++
++ squash remark
++
++ amended message
++
++ EOF
+'
+
+test_expect_success '--reedit-message groups fixups under their targets' '
+ git reset --hard start &&
+ test_commit --no-tag alpha file a1 &&
+ test_commit --no-tag beta file b1 &&
-+ printf "fixup! alpha\n" >msg &&
-+ echo a2 >file &&
-+ git add file &&
-+ git commit -qF msg &&
-+ printf "fixup! beta\n" >msg &&
-+ echo b2 >file &&
-+ git add file &&
-+ git commit -qF msg &&
++ stage_file a2 &&
++ commit_with_message "fixup! alpha\n" &&
++ stage_file b2 &&
++ commit_with_message "fixup! beta\n" &&
+
+ write_script editor <<-\EOF &&
+ cat "$1" >edited
@@ t/t3455-history-squash.sh: test_expect_success 'preserves authorship of the olde
+test_expect_success '--reedit-message lets amend! replace its target message' '
+ git reset --hard start &&
+ test_commit --no-tag mark-base file b &&
-+ printf "amend! mark-base\n\namended message\n" >msg &&
-+ echo c >file &&
-+ git add file &&
-+ git commit -qF msg &&
-+ printf "squash! mark-base\n\nsquash remark\n" >msg &&
-+ echo d >file &&
-+ git add file &&
-+ git commit -qF msg &&
++ stage_file c &&
++ commit_with_message "amend! mark-base\n\namended message\n" &&
++ stage_file d &&
++ commit_with_message "squash! mark-base\n\nsquash remark\n" &&
+
+ write_script editor <<-\EOF &&
+ cat "$1" >edited
@@ t/t3455-history-squash.sh: test_expect_success 'preserves authorship of the olde
+ #
+ EOF
+ test_cmp expect edited &&
-+ git log -1 --format="%B" >final &&
-+ test_grep ! "mark-base" final &&
-+ test_grep "amended message" final &&
-+ test_grep "squash remark" final
++ check_log_messages -1 <<-\EOF
++ amended message
++
++ squash remark
++
++ EOF
+'
+
+test_expect_success '--reedit-message aborts on an empty message' 'Harald Nordgren via GitGitGadget <gitgitgadget@gmail.com>