[PATCH v6 0/4] history: add squash subcommand to fold a range

["Harald Nordgren via GitGitGadget" <gitgitgadget@gmail.com>]

Adds git history squash <revision-range> to fold a range of commits.

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 (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   |  29 ++
 advice.c                         |   1 +
 advice.h                         |   1 +
 builtin/history.c                | 357 +++++++++++++++++---
 t/meson.build                    |   1 +
 t/t3455-history-squash.sh        | 550 +++++++++++++++++++++++++++++++
 7 files changed, 905 insertions(+), 38 deletions(-)
 create mode 100755 t/t3455-history-squash.sh


base-commit: 6c3d7b73556db708feb3b16232fab1efc4353428
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2337%2FHaraldNordgren%2Frebase-fixup-fold-v6
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2337/HaraldNordgren/rebase-fixup-fold-v6
Pull-Request: https://github.com/git/git/pull/2337

Range-diff vs v5:

 1:  0f1ae9b05a = 1:  fea6b79e60 history: extract helper for a commit's parent tree
 2:  a97ffab1e6 = 2:  e2674e0bc4 history: give commit_tree_ext a message template
 3:  04e18ef979 ! 3:  811e393ab4 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, so the
     -    range collapses into a single commit. Commits above the range are
     -    replayed on top of the result.
     +    message and authorship and taking the tree of the newest commit, then
     +    replays the commits above the range on top. fixup!, squash! and amend!
     +    commits are folded like any other and are not interpreted, so the
     +    squashed message comes from the oldest commit, or from an editor with
     +    --reedit-message.
      
     -    The range is given as <base>..<tip>, so "git history squash @~3.."
     -    folds the three most recent commits and "git history squash @~5..@~2"
     -    squashes an interior range. A merge inside the range is folded like any
     -    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.
     +    The range is read like the arguments to "git rev-list", so several
     +    arguments such as "@~3.. ^topic" are allowed. A merge inside the range
     +    is folded when its other parent is reachable from the base, otherwise
     +    the range has more than one base and is rejected. By default the command
     +    also refuses when a ref points at a commit that the fold would discard.
     +    Use --update-refs=head to rewrite only the current branch instead.
      
          Inspired-by: Sergey Chernov <serega.morph@gmail.com>
          Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
     @@ Documentation/git-history.adoc: linkgit:gitglossary[7].
      +the commit just below the oldest commit to squash. For example, `git
      +history squash @~3..` folds the three most recent commits into one, and
      +`git history squash @~5..@~2` squashes an interior range while leaving
     -+the two newest commits in place.
     ++the two newest commits in place. _<revision-range>_ is read like the
     ++arguments to linkgit:git-rev-list[1], so several arguments may be given,
     ++for example `@~3.. ^topic` to additionally exclude what is already on
     ++`topic`.
      ++
      +The oldest commit's message and authorship are preserved by default,
      +unless you specify `--reedit-message`. A merge commit inside the range is
     @@ builtin/history.c: out:
      + * but the range must have a single base and must not reach a root commit.
      + */
      +static int resolve_squash_range(struct repository *repo,
     -+				const char *range,
     ++				const char **argv,
      +				struct commit **base_out,
      +				struct commit **oldest_out,
      +				struct commit **tip_out,
     @@ builtin/history.c: out:
      +{
      +	struct rev_info revs;
      +	struct commit *commit, *base = NULL, *oldest = NULL, *tip = NULL;
     ++	struct commit_list *boundaries = NULL, *b;
      +	struct strvec args = STRVEC_INIT;
      +	size_t i;
      +	int ret;
     @@ builtin/history.c: out:
      +	strvec_push(&args, "--topo-order");
      +	strvec_push(&args, "--boundary");
      +	strvec_push(&args, "--ancestry-path");
     -+	strvec_push(&args, range);
     ++	strvec_pushv(&args, argv);
      +	setup_revisions_from_strvec(&args, &revs, NULL);
      +	if (args.nr != 1) {
     -+		ret = error(_("'%s' does not name a revision range"), range);
     ++		ret = error(_("unrecognized argument: %s"), args.v[1]);
      +		goto out;
      +	}
      +
      +	/*
     -+	 * A squash needs a base to reparent onto, so the argument has to
     -+	 * exclude something, as in "<base>..<tip>". A single revision has no
     -+	 * such bottom commit and cannot be squashed.
     ++	 * A squash needs a base to reparent onto, so the range has to exclude
     ++	 * something, as in "<base>..<tip>". A revision range with no such
     ++	 * bottom commit cannot be squashed.
      +	 */
      +	for (i = 0; i < revs.cmdline.nr; i++)
      +		if (revs.cmdline.rev[i].flags & UNINTERESTING)
      +			break;
      +	if (i == revs.cmdline.nr) {
     -+		ret = error(_("'%s' is not a '<base>..<tip>' range"), range);
     ++		ret = error(_("not a '<base>..<tip>' revision range"));
      +		goto out;
      +	}
      +
     @@ builtin/history.c: out:
      +
      +	while ((commit = get_revision(&revs))) {
      +		if (commit->object.flags & BOUNDARY) {
     -+			if (base) {
     -+				ret = error(_("range '%s' has more than one base; "
     -+					      "cannot squash"), range);
     -+				goto out;
     -+			}
     -+			base = commit;
     ++			commit_list_insert(commit, &boundaries);
      +			continue;
      +		}
      +		if (!oldest)
     @@ builtin/history.c: out:
      +	}
      +
      +	if (!oldest) {
     -+		ret = error(_("the range '%s' is empty"), range);
     ++		ret = error(_("the revision range is empty"));
     ++		goto out;
     ++	}
     ++
     ++	if (oldest == tip) {
     ++		ret = error(_("the revision range holds a single commit; "
     ++			      "nothing to squash"));
      +		goto out;
      +	}
      +
     -+	if (!base)
     -+		BUG("a non-empty range must have a boundary commit");
     ++	if (!oldest->parents)
     ++		BUG("an in-range commit must have a parent");
     ++	base = oldest->parents->item;
     ++
     ++	/*
     ++	 * A boundary other than the base is an in-range commit reaching a
     ++	 * commit outside the range, so the range has more than one base.
     ++	 */
     ++	for (b = boundaries; b; b = b->next) {
     ++		if (b->item != base) {
     ++			ret = error(_("the revision range has more than one base; "
     ++				      "cannot squash"));
     ++			goto out;
     ++		}
     ++	}
      +
      +	*base_out = base;
      +	*oldest_out = oldest;
     @@ builtin/history.c: out:
      +	ret = 0;
      +
      +out:
     ++	commit_list_free(boundaries);
      +	reset_revision_walk();
      +	release_revisions(&revs);
      +	strvec_clear(&args);
     @@ builtin/history.c: out:
      +	int ret;
      +
      +	argc = parse_options(argc, argv, prefix, options, usage, 0);
     -+	if (argc != 1) {
     -+		ret = error(_("command expects a single revision range"));
     ++	if (!argc) {
     ++		ret = error(_("command expects a revision range"));
      +		goto out;
      +	}
      +	repo_config(repo, git_default_config, 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, &base, &oldest, &tip,
      +				   &interior);
      +	if (ret < 0)
      +		goto out;
     @@ t/t3455-history-squash.sh (new)
      +
      +test_expect_success 'errors on missing range argument' '
      +	test_must_fail git history squash 2>err &&
     -+	test_grep "command expects a single revision range" err
     -+'
     -+
     -+test_expect_success 'errors on too many arguments' '
     -+	test_must_fail git history squash start.. HEAD 2>err &&
     -+	test_grep "command expects a single revision range" err
     ++	test_grep "expects a revision range" err
      +'
      +
      +test_expect_success 'errors on an empty range' '
      +	test_must_fail git history squash HEAD..HEAD 2>err &&
     -+	test_grep "the range .* is empty" err
     ++	test_grep "the revision range is empty" err
      +'
      +
      +test_expect_success 'errors on a single revision that is not a range' '
      +	test_must_fail git history squash HEAD 2>err &&
     -+	test_grep "is not a .*range" err &&
     ++	test_grep "not a .*range" err &&
      +	test_must_fail git history squash HEAD~1 2>err &&
     -+	test_grep "is not a .*range" err
     ++	test_grep "not a .*range" err
     ++'
     ++
     ++test_expect_success 'errors on a range holding a single commit' '
     ++	git reset --hard three &&
     ++	head_before=$(git rev-parse HEAD) &&
     ++
     ++	test_must_fail git history squash "HEAD^!" 2>err &&
     ++	test_grep "single commit; nothing to squash" err &&
     ++	test_cmp_rev "$head_before" HEAD
     ++'
     ++
     ++test_expect_success 'accepts multiple revision arguments with an exclusion' '
     ++	git reset --hard three &&
     ++	git branch -f keep HEAD~2 &&
     ++	tip_tree=$(git rev-parse HEAD^{tree}) &&
     ++
     ++	git history squash start..HEAD ^keep &&
     ++
     ++	git log --format="%s" start..HEAD >actual &&
     ++	cat >expect <<-\EOF &&
     ++	two
     ++	one
     ++	EOF
     ++	test_cmp expect actual &&
     ++	test_cmp_rev keep HEAD~1 &&
     ++	test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
     ++
     ++	git branch -D keep
     ++'
     ++
     ++test_expect_success 'squashes a branch the current branch is not on' '
     ++	git reset --hard three &&
     ++	main=$(git symbolic-ref --short HEAD) &&
     ++	head_before=$(git rev-parse HEAD) &&
     ++	git checkout -b off-history start &&
     ++	test_commit --no-tag off-one off a &&
     ++	test_commit --no-tag off-two off b &&
     ++	git checkout "$main" &&
     ++
     ++	git history squash start..off-history &&
     ++
     ++	git rev-list --count start..off-history >count &&
     ++	echo 1 >expect &&
     ++	test_cmp expect count &&
     ++	test_cmp_rev "$head_before" HEAD &&
     ++
     ++	git branch -D off-history
      +'
      +
      +test_expect_success 'squashes a range into a single commit without changing the tree' '
     @@ t/t3455-history-squash.sh (new)
      +	test "$tip_tree" = "$(git rev-parse HEAD^{tree})"
      +'
      +
     -+test_expect_success 'squashing a single-commit range replays the rest' '
     -+	git reset --hard three &&
     -+	tip_tree=$(git rev-parse HEAD^{tree}) &&
     -+
     -+	git history squash start..@~2 &&
     -+
     -+	git log --format="%s" start..HEAD >actual &&
     -+	cat >expect <<-\EOF &&
     -+	three
     -+	two
     -+	one
     -+	EOF
     -+	test_cmp expect actual &&
     -+	test "$tip_tree" = "$(git rev-parse HEAD^{tree})"
     -+'
      +
      +test_expect_success 'reuses the message of a fixup! commit in the range' '
      +	git reset --hard start &&
     @@ t/t3455-history-squash.sh (new)
      +
      +test_expect_success 'squashes a range whose internal merge has a single base' '
      +	git reset --hard start &&
     ++	main=$(git symbolic-ref --short HEAD) &&
      +	test_commit --no-tag before-side file b &&
      +	git checkout -b inner-side &&
      +	test_commit --no-tag on-inner-side inner x &&
     -+	git checkout - &&
     ++	git checkout "$main" &&
      +	test_commit --no-tag after-side file c &&
      +	git merge --no-ff -m merge inner-side &&
      +	git branch -D inner-side &&
     @@ t/t3455-history-squash.sh (new)
      +
      +test_expect_success 'folds a merge of a branch that forked at the base' '
      +	git reset --hard start &&
     ++	main=$(git symbolic-ref --short HEAD) &&
      +	git checkout -b base-fork-side &&
      +	test_commit --no-tag base-fork-side side x &&
     -+	git checkout - &&
     ++	git checkout "$main" &&
      +	test_commit --no-tag base-fork-main file b &&
      +	git merge --no-ff -m "merge base-fork-side" base-fork-side &&
      +	git branch -D base-fork-side &&
     @@ t/t3455-history-squash.sh (new)
      +	test_path_is_file side
      +'
      +
     ++test_expect_success 'refuses a merge whose other parent is outside the range' '
     ++	git reset --hard start &&
     ++	main=$(git symbolic-ref --short HEAD) &&
     ++	git checkout -b outside-parent &&
     ++	test_commit --no-tag outside-parent outside x &&
     ++	git checkout "$main" &&
     ++	test_commit --no-tag outside-main file b &&
     ++	base=$(git rev-parse HEAD) &&
     ++	test_commit --no-tag outside-mid file c &&
     ++	git merge --no-ff -m "merge outside-parent" outside-parent &&
     ++	git branch -D outside-parent &&
     ++	merged=$(git rev-parse HEAD) &&
     ++
     ++	test_must_fail git history squash "$base.." 2>err &&
     ++	test_grep "more than one base" err &&
     ++	test_cmp_rev "$merged" HEAD
     ++'
     ++
      +test_expect_success 'folds a range whose tip is a merge commit' '
      +	git reset --hard start &&
     ++	main=$(git symbolic-ref --short HEAD) &&
      +	test_commit --no-tag tipmerge-base file b &&
      +	git checkout -b tipmerge-side &&
      +	test_commit --no-tag tipmerge-side side x &&
     -+	git checkout - &&
     ++	git checkout "$main" &&
      +	test_commit --no-tag tipmerge-main file c &&
      +	git merge --no-ff -m "merge tipmerge-side" tipmerge-side &&
      +	git branch -D tipmerge-side &&
     @@ t/t3455-history-squash.sh (new)
      +
      +test_expect_success 'folds a range whose base is a merge commit' '
      +	git reset --hard start &&
     ++	main=$(git symbolic-ref --short HEAD) &&
      +	git checkout -b basemerge-side &&
      +	test_commit --no-tag basemerge-side side x &&
     -+	git checkout - &&
     ++	git checkout "$main" &&
      +	test_commit --no-tag basemerge-main file b &&
      +	git merge --no-ff -m "merge basemerge-side" basemerge-side &&
      +	git branch -D basemerge-side &&
     @@ t/t3455-history-squash.sh (new)
      +
      +test_expect_success 'refuses to squash a range with more than one base' '
      +	git reset --hard start &&
     -+	head_before=$(git rev-parse HEAD) &&
     ++	main=$(git symbolic-ref --short HEAD) &&
      +	git checkout -b forked-before &&
      +	test_commit forked-side fside x &&
     -+	git checkout - &&
     -+	test_commit forked-main file b &&
     ++	git checkout "$main" &&
     ++	test_commit forked-base file b &&
     ++	base=$(git rev-parse HEAD) &&
     ++	test_commit forked-main file c &&
      +	git merge --no-ff -m merge forked-before &&
      +	merged=$(git rev-parse HEAD) &&
      +
     -+	test_must_fail git history squash forked-main.. 2>err &&
     ++	test_must_fail git history squash "$base.." 2>err &&
      +	test_grep "more than one base" err &&
      +	test_cmp_rev "$merged" HEAD
      +'
      +
      +test_expect_success 'folds a range with two interior merges' '
      +	git reset --hard start &&
     ++	main=$(git symbolic-ref --short HEAD) &&
      +	test_commit --no-tag two-merge-a file a1 &&
      +	git checkout -b two-merge-s1 &&
      +	test_commit --no-tag two-merge-s1 s1 x &&
     -+	git checkout - &&
     ++	git checkout "$main" &&
      +	git merge --no-ff -m "merge s1" two-merge-s1 &&
      +	test_commit --no-tag two-merge-b file b1 &&
      +	git checkout -b two-merge-s2 &&
      +	test_commit --no-tag two-merge-s2 s2 y &&
     -+	git checkout - &&
     ++	git checkout "$main" &&
      +	git merge --no-ff -m "merge s2" two-merge-s2 &&
      +	git branch -D two-merge-s1 two-merge-s2 &&
      +	tip_tree=$(git rev-parse HEAD^{tree}) &&
     @@ t/t3455-history-squash.sh (new)
      +test_expect_success 'refuses when a descendant above the range is a merge' '
      +	git reset --hard start &&
      +	main=$(git symbolic-ref --short HEAD) &&
     -+	test_commit --no-tag desc-base file b &&
     ++	test_commit --no-tag desc-one file b &&
     ++	test_commit --no-tag desc-two file c &&
      +	git tag desc-tip &&
      +	git checkout -b desc-above &&
      +	test_commit --no-tag desc-above above x &&
      +	git checkout "$main" &&
     -+	test_commit --no-tag desc-main file c &&
     ++	test_commit --no-tag desc-main file d &&
      +	git merge --no-ff -m "merge desc-above" desc-above &&
      +	git branch -D desc-above &&
      +	head_before=$(git rev-parse HEAD) &&
 4:  a758e1f084 ! 4:  4edf012b77 history: re-edit a squash with every message
     @@ Commit message
      
          Gather the messages of every commit in the range, oldest first, and use
          them as the editor template when re-editing, mirroring how "git rebase
     -    -i" presents a squash. The combined message is built before the
     -    descendant walk so it is not disturbed by the flags that walk leaves on
     -    the commits.
     +    -i" presents a squash.
      
          Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
      
       ## Documentation/git-history.adoc ##
     -@@ Documentation/git-history.adoc: history squash @~3..` folds the three most recent commits into one, and
     - `git history squash @~5..@~2` squashes an interior range while leaving
     - the two newest commits in place.
     +@@ Documentation/git-history.adoc: arguments to linkgit:git-rev-list[1], so several arguments may be given,
     + for example `@~3.. ^topic` to additionally exclude what is already on
     + `topic`.
       +
      -The oldest commit's message and authorship are preserved by default,
      -unless you specify `--reedit-message`. A merge commit inside the range is

-- 
gitgitgadget