Adds git history squash <revision-range> to fold a range of commits.
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 (4):
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
history: re-edit a squash with every message
Documentation/config/advice.adoc | 4 +
Documentation/git-history.adoc | 26 +++
advice.c | 1 +
advice.h | 1 +
builtin/history.c | 328 +++++++++++++++++++++++++----
t/meson.build | 1 +
t/t3455-history-squash.sh | 340 +++++++++++++++++++++++++++++++
7 files changed, 663 insertions(+), 38 deletions(-)
create mode 100755 t/t3455-history-squash.sh
base-commit: 8d96f09e9245ddf80c1981476fcbac8c4bb4125f
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2337%2FHaraldNordgren%2Frebase-fixup-fold-v4
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2337/HaraldNordgren/rebase-fixup-fold-v4
Pull-Request: https://github.com/git/git/pull/2337
Range-diff vs v3:
1: 1e31474ef6 = 1: fc2801c0b1 history: extract helper for a commit's parent tree
2: 498da64046 = 2: ee591e83b4 history: give commit_tree_ext a message template
3: 66b2f49fb4 ! 3: 80bfea642e history: add squash subcommand to fold a range
@@ Commit message
other commit, but the range must have a single base, so a range with
more than one entry point is rejected.
+ The folded commits leave the history, so by default the command refuses
+ when another ref points at one of them. Use "--update-refs=head" to
+ rewrite only the current branch and leave those refs untouched.
+
Inspired-by: Sergey Chernov <serega.morph@gmail.com>
Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
+ ## Documentation/config/advice.adoc ##
+@@ Documentation/config/advice.adoc: all advice messages.
+ forceDeleteBranch::
+ Shown when the user tries to delete a not fully merged
+ branch without the force option set.
++ historyUpdateRefs::
++ Shown when `git history squash` refuses because a ref points
++ into the range being folded, to tell the user about
++ `--update-refs=head`.
+ ignoredHook::
+ Shown when a hook is ignored because the hook is not
+ set as executable.
+
## Documentation/git-history.adoc ##
@@ Documentation/git-history.adoc: SYNOPSIS
git history fixup <commit> [--dry-run] [--update-refs=(branches|head)] [--reedit-message] [--empty=(drop|keep|abort)]
@@ Documentation/git-history.adoc: linkgit:gitglossary[7].
+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 folded commits disappear from the history, so with the default
++`--update-refs=branches` the command refuses when another ref points at
++one of them. Rerun with `--update-refs=head` to rewrite only the current
++branch and leave those refs pointing at the old commits.
+
OPTIONS
-------
+ ## advice.c ##
+@@ advice.c: static struct {
+ [ADVICE_FETCH_SHOW_FORCED_UPDATES] = { "fetchShowForcedUpdates" },
+ [ADVICE_FORCE_DELETE_BRANCH] = { "forceDeleteBranch" },
+ [ADVICE_GRAFT_FILE_DEPRECATED] = { "graftFileDeprecated" },
++ [ADVICE_HISTORY_UPDATE_REFS] = { "historyUpdateRefs" },
+ [ADVICE_IGNORED_HOOK] = { "ignoredHook" },
+ [ADVICE_IMPLICIT_IDENTITY] = { "implicitIdentity" },
+ [ADVICE_MERGE_CONFLICT] = { "mergeConflict" },
+
+ ## advice.h ##
+@@ advice.h: enum advice_type {
+ ADVICE_FETCH_SHOW_FORCED_UPDATES,
+ ADVICE_FORCE_DELETE_BRANCH,
+ ADVICE_GRAFT_FILE_DEPRECATED,
++ ADVICE_HISTORY_UPDATE_REFS,
+ ADVICE_IGNORED_HOOK,
+ ADVICE_IMPLICIT_IDENTITY,
+ ADVICE_MERGE_CONFLICT,
+
## builtin/history.c ##
+@@
+ #define USE_THE_REPOSITORY_VARIABLE
+
+ #include "builtin.h"
++#include "advice.h"
+ #include "cache-tree.h"
+ #include "commit.h"
+ #include "commit-reach.h"
@@
N_("git history reword <commit> [--dry-run] [--update-refs=(branches|head)]")
#define GIT_HISTORY_SPLIT_USAGE \
@@ builtin/history.c: out:
+ const char *range,
+ struct commit **base_out,
+ struct commit **oldest_out,
-+ struct commit **tip_out)
++ struct commit **tip_out,
++ struct oidset *interior_out)
+{
+ struct rev_info revs;
+ struct commit *commit, *base = NULL, *oldest = NULL, *tip = NULL;
@@ builtin/history.c: out:
+ }
+ if (!oldest)
+ oldest = commit;
++ if (tip)
++ oidset_insert(interior_out, &tip->object.oid);
+ tip = commit;
+ }
+
@@ builtin/history.c: out:
+ return ret;
+}
+
++struct interior_ref_cb {
++ const struct oidset *interior;
++ const char *name;
++};
++
++static int find_interior_ref(const struct reference *ref, void *cb_data)
++{
++ struct interior_ref_cb *data = cb_data;
++
++ if (oidset_contains(data->interior, ref->oid)) {
++ data->name = xstrdup(ref->name);
++ return 1;
++ }
++
++ return 0;
++}
++
+static int cmd_history_squash(int argc,
+ const char **argv,
+ const char *prefix,
@@ builtin/history.c: out:
+ OPT_END(),
+ };
+ struct strbuf reflog_msg = STRBUF_INIT;
++ struct oidset interior = OIDSET_INIT;
+ struct commit *base, *oldest, *tip, *rewritten;
+ const struct object_id *base_tree_oid, *tip_tree_oid;
+ struct commit_list *parents = NULL;
@@ builtin/history.c: out:
+ if (action == REF_ACTION_DEFAULT)
+ action = REF_ACTION_BRANCHES;
+
-+ ret = resolve_squash_range(repo, argv[0], &base, &oldest, &tip);
++ ret = resolve_squash_range(repo, argv[0], &base, &oldest, &tip,
++ &interior);
+ if (ret < 0)
+ goto out;
+
++ if (action == REF_ACTION_BRANCHES) {
++ struct interior_ref_cb cb = { .interior = &interior };
++
++ refs_for_each_ref(get_main_ref_store(repo),
++ find_interior_ref, &cb);
++ if (cb.name) {
++ ret = error(_("'%s' points into the squashed range"),
++ cb.name);
++ advise_if_enabled(ADVICE_HISTORY_UPDATE_REFS,
++ _("Use --update-refs=head to rewrite only "
++ "the current branch and leave such refs "
++ "untouched."));
++ free((char *)cb.name);
++ goto out;
++ }
++ }
++
+ ret = setup_revwalk(repo, action, tip, &revs);
+ if (ret < 0)
+ goto out;
@@ builtin/history.c: out:
+
+out:
+ strbuf_release(&reflog_msg);
++ oidset_clear(&interior);
+ commit_list_free(parents);
+ release_revisions(&revs);
+ return ret;
@@ t/meson.build: integration_tests = [
't3451-history-reword.sh',
't3452-history-split.sh',
't3453-history-fixup.sh',
-+ 't3454-history-squash.sh',
++ 't3455-history-squash.sh',
't3500-cherry.sh',
't3501-revert-cherry-pick.sh',
't3502-cherry-pick-merge.sh',
- ## t/t3454-history-squash.sh (new) ##
+ ## t/t3455-history-squash.sh (new) ##
@@
+#!/bin/sh
+
@@ t/t3454-history-squash.sh (new)
+test_expect_success 'setup linear history touching two files' '
+ test_commit base file a &&
+ git tag start &&
-+ test_commit one other x &&
-+ test_commit two file c &&
++ test_commit --no-tag one other x &&
++ test_commit --no-tag two file c &&
+ test_commit three file d
+'
+
@@ t/t3454-history-squash.sh (new)
+
+test_expect_success 'reuses the message of a fixup! commit in the range' '
+ git reset --hard start &&
-+ test_commit reg1 file b &&
++ test_commit --no-tag reg1 file b &&
+ git commit --allow-empty -m "fixup! reg1" &&
+ test_commit reg2 file c &&
+
@@ t/t3454-history-squash.sh (new)
+test_expect_success 'preserves authorship of the oldest commit' '
+ git reset --hard start &&
+ GIT_AUTHOR_NAME=Squasher GIT_AUTHOR_EMAIL=squash@example.com \
-+ test_commit oldest file b &&
++ test_commit --no-tag oldest file b &&
+ test_commit newest file c &&
+
+ git history squash start.. &&
@@ t/t3454-history-squash.sh (new)
+test_expect_success '--dry-run predicts the rewrite without performing it' '
+ git reset --hard three &&
+ head_before=$(git rev-parse HEAD) &&
++ tip_tree=$(git rev-parse HEAD^{tree}) &&
+
+ git history squash --dry-run start.. >out &&
-+ grep "^update refs/heads/" out >update &&
-+ predicted=$(awk "{print \$3}" update) &&
++ predicted=$(awk "/^update refs\/heads\// {print \$3}" out) &&
+ test_cmp_rev "$head_before" HEAD &&
+
+ git history squash start.. &&
-+ test "$predicted" = "$(git rev-parse HEAD)"
++ test "$predicted" = "$(git rev-parse HEAD)" &&
++ git rev-list --count start..HEAD >count &&
++ echo 1 >expect &&
++ test_cmp expect count &&
++ test_cmp_rev start HEAD^ &&
++ test "$tip_tree" = "$(git rev-parse HEAD^{tree})"
+'
+
+test_expect_success '--update-refs=head only moves HEAD' '
@@ t/t3454-history-squash.sh (new)
+ test_cmp_rev "$other_before" other
+'
+
-+test_expect_success '--update-refs=branches moves a branch pointing into the range' '
++test_expect_success 'refuses to fold a range a ref points into' '
++ git reset --hard three &&
++ git branch -f mid HEAD~1 &&
++ head_before=$(git rev-parse HEAD) &&
++
++ test_must_fail git history squash start.. 2>err &&
++ test_grep "error: .* points into the squashed range" err &&
++ test_grep "hint: .*--update-refs=head" err &&
++ test_cmp_rev "$head_before" HEAD &&
++
++ git branch -D mid
++'
++
++test_expect_success 'advice.historyUpdateRefs silences the hint' '
++ git reset --hard three &&
++ git branch -f mid HEAD~1 &&
++
++ test_must_fail git -c advice.historyUpdateRefs=false \
++ history squash start.. 2>err &&
++ test_grep "points into the squashed range" err &&
++ test_grep ! "hint:" err &&
++
++ git branch -D mid
++'
++
++test_expect_success '--update-refs=head folds past a ref pointing into the range' '
+ git reset --hard three &&
-+ git branch -f mid HEAD~2 &&
++ git branch -f mid HEAD~1 &&
+ mid_before=$(git rev-parse mid) &&
+
-+ git history squash start..@~1 &&
++ git history squash --update-refs=head start.. &&
+
++ git rev-list --count start..HEAD >count &&
++ echo 1 >expect &&
++ test_cmp expect count &&
+ test_cmp_rev "$mid_before" mid &&
-+ test_commit_message mid -m one
++
++ git branch -D mid
++'
++
++test_expect_success 'refuses to fold a range a tag points into' '
++ git reset --hard three &&
++ git tag -f mark HEAD~1 &&
++ head_before=$(git rev-parse HEAD) &&
++
++ test_must_fail git history squash start.. 2>err &&
++ test_grep "refs/tags/mark" err &&
++ test_grep "points into the squashed range" err &&
++ test_cmp_rev "$head_before" HEAD &&
++
++ git tag -d mark
+'
+
+test_expect_success 'squashes a range whose internal merge has a single base' '
+ git reset --hard start &&
-+ test_commit before-side file b &&
++ test_commit --no-tag before-side file b &&
+ git checkout -b inner-side &&
-+ test_commit on-inner-side inner x &&
++ test_commit --no-tag on-inner-side inner x &&
+ git checkout - &&
-+ test_commit after-side file c &&
++ test_commit --no-tag after-side file c &&
+ git merge --no-ff -m merge inner-side &&
-+ test_commit after-merge file d &&
++ git branch -D inner-side &&
++ test_commit --no-tag after-merge file d &&
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
+
+ git history squash start.. &&
@@ t/t3454-history-squash.sh (new)
+ test_path_is_file inner
+'
+
++test_expect_success 'folds a range whose tip is a merge commit' '
++ git reset --hard start &&
++ test_commit --no-tag tipmerge-base file b &&
++ git checkout -b tipmerge-side &&
++ test_commit --no-tag tipmerge-side side x &&
++ git checkout - &&
++ test_commit --no-tag tipmerge-main file c &&
++ git merge --no-ff -m "merge tipmerge-side" tipmerge-side &&
++ git branch -D tipmerge-side &&
++ tip_tree=$(git rev-parse HEAD^{tree}) &&
++
++ git history squash start.. &&
++
++ git rev-list --count start..HEAD >count &&
++ echo 1 >expect &&
++ test_cmp expect count &&
++ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
++ test_path_is_file side
++'
++
++test_expect_success 'folds a range whose base is a merge commit' '
++ git reset --hard start &&
++ git checkout -b basemerge-side &&
++ test_commit --no-tag basemerge-side side x &&
++ git checkout - &&
++ test_commit --no-tag basemerge-main file b &&
++ git merge --no-ff -m "merge basemerge-side" basemerge-side &&
++ git branch -D basemerge-side &&
++ base=$(git rev-parse HEAD) &&
++ test_commit --no-tag basemerge-one file c &&
++ test_commit --no-tag basemerge-two file d &&
++ tip_tree=$(git rev-parse HEAD^{tree}) &&
++
++ git history squash "$base.." &&
++
++ git rev-list --count "$base..HEAD" >count &&
++ echo 1 >expect &&
++ test_cmp expect count &&
++ test_cmp_rev "$base" HEAD^ &&
++ test "$tip_tree" = "$(git rev-parse HEAD^{tree})"
++'
++
+test_expect_success 'refuses to squash a range with more than one base' '
+ git reset --hard start &&
+ head_before=$(git rev-parse HEAD) &&
4: 43e4270614 ! 4: 85c7817d7e history: re-edit a squash with every message
@@ Documentation/git-history.adoc: history squash @~3..` folds the three most recen
forked before the range and was later merged into it) is rejected.
## builtin/history.c ##
-@@ builtin/history.c: out:
- return ret;
+@@ builtin/history.c: static int find_interior_ref(const struct reference *ref, void *cb_data)
+ return 0;
}
+static int build_squash_message(struct repository *repo,
@@ builtin/history.c: static int cmd_history_squash(int argc,
};
struct strbuf reflog_msg = STRBUF_INIT;
+ struct strbuf message = STRBUF_INIT;
+ struct oidset interior = OIDSET_INIT;
struct commit *base, *oldest, *tip, *rewritten;
const struct object_id *base_tree_oid, *tip_tree_oid;
- struct commit_list *parents = NULL;
@@ builtin/history.c: static int cmd_history_squash(int argc,
- if (ret < 0)
- goto out;
+ }
+ }
+ if (flags & COMMIT_TREE_EDIT_MESSAGE) {
+ ret = build_squash_message(repo, base, tip, &message);
@@ 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);
- return ret;
- ## t/t3454-history-squash.sh ##
-@@ t/t3454-history-squash.sh: test_expect_success 'preserves authorship of the oldest commit' '
+ ## t/t3455-history-squash.sh ##
+@@ t/t3455-history-squash.sh: test_expect_success 'preserves authorship of the oldest commit' '
test_cmp expect actual
'
@@ t/t3454-history-squash.sh: test_expect_success 'preserves authorship of the olde
+ echo b >file &&
+ git add file &&
+ git commit -m "re-one subject" -m "re-one body line" &&
-+ test_commit re-two file c &&
++ test_commit --no-tag re-two file c &&
+ test_commit re-three file d &&
+
+ write_script editor <<-\EOF &&
@@ t/t3454-history-squash.sh: test_expect_success 'preserves authorship of the olde
+ test_set_editor "$(pwd)/editor" &&
+ git history squash --reedit-message start.. &&
+
-+ grep "re-one subject" buffer &&
-+ grep "re-one body line" buffer &&
-+ grep re-two buffer &&
-+ grep re-three buffer &&
++ test_grep "re-one subject" buffer &&
++ test_grep "re-one body line" buffer &&
++ test_grep re-two buffer &&
++ test_grep re-three buffer &&
+ git log --format="%s" -1 >actual &&
+ echo combined >expect &&
+ test_cmp expect actualHarald Nordgren via GitGitGadget <gitgitgadget@gmail.com>