diff mbox series

[3/3] wt-status: suggest 'git rebase --continue' to conclude 'merge' instruction

Message ID db01acdd062a17b1cca62428eba8c3ed62ca7c6a.1743181401.git.gitgitgadget@gmail.com (mailing list archive)
State New
Headers show
Series rebase -r: a bugfix and two status-related improvements | expand

Commit Message

Philippe Blain March 28, 2025, 5:03 p.m. UTC
From: Philippe Blain <levraiphilippeblain@gmail.com>

Since 982288e9bd (status: rebase and merge can be in progress at the
same time, 2018-11-12), when a merge is in progress as part of a 'git
rebase -r' operation, 'wt_longstatus_print_state' shows information
about the in-progress rebase (via show_rebase_information), and then
calls 'show_merge_in_progress' to help the user conclude the merge. This
function suggests using 'git commit' to do so, but this throws away the
authorship information from the original merge, which is not ideal.
Using 'git rebase --continue' instead preserves the authorship
information, since we enter 'sequencer.c:run_git_commit' which calls
read_env_script to read the author-script file.

Note however that this only works when a merge was scheduled using a
'merge' instruction in the rebase todo list. Indeed, when using 'exec
git merge', the state files necessary for 'git rebase --continue' are
not present, and one must use 'git commit' (or 'git merge --continue')
in that case.

Be more helpful to the user by suggesting either 'git rebase
--continue', when the merge was scheduled using a 'merge' instruction,
and 'git commit' otherwise. As such, add a
'merge_during_rebase_in_progress' field to 'struct wt_status_state', and
detect this situation in wt_status_check_rebase by looking at the last
command done. Adjust wt_longstatus_print_state to check this field and
suggest 'git rebase --continue' if a merge came from a 'merge'
instruction, by calling show_rebase_in_progress directly.

Add two tests for the new behaviour, using 'merge' and 'exec git merge'
instructions.

Signed-off-by: Philippe Blain <levraiphilippeblain@gmail.com>
---
 t/t7512-status-help.sh | 75 ++++++++++++++++++++++++++++++++++++++++++
 wt-status.c            | 18 +++++++---
 wt-status.h            |  1 +
 3 files changed, 90 insertions(+), 4 deletions(-)

Comments

Phillip Wood March 31, 2025, 3:38 p.m. UTC | #1
Hi Philippe

On 28/03/2025 17:03, Philippe Blain via GitGitGadget wrote:
> From: Philippe Blain <levraiphilippeblain@gmail.com>
> 
> Since 982288e9bd (status: rebase and merge can be in progress at the
> same time, 2018-11-12), when a merge is in progress as part of a 'git
> rebase -r' operation, 'wt_longstatus_print_state' shows information
> about the in-progress rebase (via show_rebase_information), and then
> calls 'show_merge_in_progress' to help the user conclude the merge. This
> function suggests using 'git commit' to do so, but this throws away the
> authorship information from the original merge, which is not ideal.
> Using 'git rebase --continue' instead preserves the authorship
> information, since we enter 'sequencer.c:run_git_commit' which calls
> read_env_script to read the author-script file.

Good catch

> Note however that this only works when a merge was scheduled using a
> 'merge' instruction in the rebase todo list. Indeed, when using 'exec
> git merge', the state files necessary for 'git rebase --continue' are
> not present, and one must use 'git commit' (or 'git merge --continue')
> in that case.
> 
> Be more helpful to the user by suggesting either 'git rebase
> --continue', when the merge was scheduled using a 'merge' instruction,
> and 'git commit' otherwise. As such, add a
> 'merge_during_rebase_in_progress' field to 'struct wt_status_state', and
> detect this situation in wt_status_check_rebase by looking at the last
> command done. Adjust wt_longstatus_print_state to check this field and
> suggest 'git rebase --continue' if a merge came from a 'merge'
> instruction, by calling show_rebase_in_progress directly.
> 
> Add two tests for the new behaviour, using 'merge' and 'exec git merge'
> instructions.

Nice, thanks for adding the tests

>   
> +test_expect_success 'status during rebase -ir after conflicted merge (exec git merge)' '
> +	git reset --hard main &&
> +	git checkout -b rebase_i_merge &&
> +	test_commit unrelated &&
> +	git checkout -b rebase_i_merge_side &&
> +	test_commit side2 main.txt &&
> +	git checkout rebase_i_merge &&
> +	test_commit side1 main.txt &&
> +	PICK=$(git rev-parse --short rebase_i_merge) &&
> +	test_must_fail git merge rebase_i_merge_side &&
> +	echo side1 >main.txt &&
> +	git add main.txt &&
> +	test_tick &&
> +	git commit --no-edit &&
> +	MERGE=$(git rev-parse --short rebase_i_merge) &&
> +	ONTO=$(git rev-parse --short main) &&
> +	test_when_finished "git rebase --abort" &&
> +	FAKE_LINES="1 2 3 5 6 7 8 9 10 exec_git_merge_refs/rewritten/rebase-i-merge-side" &&
> +	export FAKE_LINES &&
> +	test_must_fail git rebase -ir main &&

As with the other patch this should be

	test_must_fail env FAKE_LINES=... git rebase ...

and the same for the test below. These tests show just how opaque the 
FAKE_LINES mechanism is - I've got no idea what it's doing. If it is not 
too much work it might be worth writing out the desired todo list to a 
file and using set_replace_editor. If you do that note that you can use 
tag names in the todo list you don't need to get the oid for each commit 
and you probably don't need to rebase the side branch, just the merge.
> @@ -1760,8 +1761,12 @@ int wt_status_check_rebase(const struct worktree *wt,
>   			state->rebase_interactive_in_progress = 1;
>   		else
>   			state->rebase_in_progress = 1;
> +		read_rebase_todolist("rebase-merge/done", &have_done);
> +		if (have_done.nr > 0 && starts_with(have_done.items[have_done.nr - 1].string, "merge"))
> +				state->merge_during_rebase_in_progress = 1;
We already read and parse the done list in show_rebase_information() - 
is it possible to avoid doing that twice by setting this flag there?

>   		state->branch = get_branch(wt, "rebase-merge/head-name");
>   		state->onto = get_branch(wt, "rebase-merge/onto");
> +		string_list_clear(&have_done, 0);
>   	} else
>   		return 0;
>   	return 1;
> @@ -1855,10 +1860,15 @@ static void wt_longstatus_print_state(struct wt_status *s)
>   
>   	if (state->merge_in_progress) {
>   		if (state->rebase_interactive_in_progress) {
> -			show_rebase_information(s, state_color);
> -			fputs("\n", s->fp);
> -		}
> -		show_merge_in_progress(s, state_color);
> +			if (state->merge_during_rebase_in_progress)
> +				show_rebase_in_progress(s, state_color);
> +			else {
> +				show_rebase_information(s, state_color);
> +				fputs("\n", s->fp);
> +				show_merge_in_progress(s, state_color);
> +			}

The indentation here looks strange

Thanks

Phillip

> +		} else
> +			show_merge_in_progress(s, state_color);
>   	} else if (state->am_in_progress)
>   		show_am_in_progress(s, state_color);
>   	else if (state->rebase_in_progress || state->rebase_interactive_in_progress)
> diff --git a/wt-status.h b/wt-status.h
> index 4e377ce62b8..84bedfcd48f 100644
> --- a/wt-status.h
> +++ b/wt-status.h
> @@ -87,6 +87,7 @@ struct wt_status_state {
>   	int am_empty_patch;
>   	int rebase_in_progress;
>   	int rebase_interactive_in_progress;
> +	int merge_during_rebase_in_progress;
>   	int cherry_pick_in_progress;
>   	int bisect_in_progress;
>   	int revert_in_progress;
Johannes Schindelin April 1, 2025, 4:22 p.m. UTC | #2
Hi Philippe,

On Fri, 28 Mar 2025, Philippe Blain via GitGitGadget wrote:

> From: Philippe Blain <levraiphilippeblain@gmail.com>
>
> Since 982288e9bd (status: rebase and merge can be in progress at the
> same time, 2018-11-12), when a merge is in progress as part of a 'git
> rebase -r' operation, 'wt_longstatus_print_state' shows information
> about the in-progress rebase (via show_rebase_information), and then
> calls 'show_merge_in_progress' to help the user conclude the merge. This
> function suggests using 'git commit' to do so, but this throws away the
> authorship information from the original merge, which is not ideal.

It is unfortunate that we cannot fix this, as `git commit` with an
interrupted `pick` _would_ retain authorship, right? (Why is that so? Can
we really not use the same trick with `merge`s?)

Ciao,
Johannes
diff mbox series

Patch

diff --git a/t/t7512-status-help.sh b/t/t7512-status-help.sh
index 802f8f704c6..b37e99625b4 100755
--- a/t/t7512-status-help.sh
+++ b/t/t7512-status-help.sh
@@ -183,6 +183,81 @@  EOF
 	test_cmp expected actual
 '
 
+test_expect_success 'status during rebase -ir after conflicted merge (exec git merge)' '
+	git reset --hard main &&
+	git checkout -b rebase_i_merge &&
+	test_commit unrelated &&
+	git checkout -b rebase_i_merge_side &&
+	test_commit side2 main.txt &&
+	git checkout rebase_i_merge &&
+	test_commit side1 main.txt &&
+	PICK=$(git rev-parse --short rebase_i_merge) &&
+	test_must_fail git merge rebase_i_merge_side &&
+	echo side1 >main.txt &&
+	git add main.txt &&
+	test_tick &&
+	git commit --no-edit &&
+	MERGE=$(git rev-parse --short rebase_i_merge) &&
+	ONTO=$(git rev-parse --short main) &&
+	test_when_finished "git rebase --abort" &&
+	FAKE_LINES="1 2 3 5 6 7 8 9 10 exec_git_merge_refs/rewritten/rebase-i-merge-side" &&
+	export FAKE_LINES &&
+	test_must_fail git rebase -ir main &&
+	cat >expect <<EOF &&
+interactive rebase in progress; onto $ONTO
+Last commands done (8 commands done):
+   pick $PICK side1
+   exec git merge refs/rewritten/rebase-i-merge-side
+  (see more in file .git/rebase-merge/done)
+No commands remaining.
+
+You have unmerged paths.
+  (fix conflicts and run "git commit")
+  (use "git merge --abort" to abort the merge)
+
+Unmerged paths:
+  (use "git add <file>..." to mark resolution)
+	both modified:   main.txt
+
+no changes added to commit (use "git add" and/or "git commit -a")
+EOF
+	git status --untracked-files=no >actual &&
+	test_cmp expect actual
+'
+
+test_expect_success 'status during rebase -ir after replaying conflicted merge (merge)' '
+	PICK=$(git rev-parse --short :/side1) &&
+	UNRELATED=$(git rev-parse --short :/unrelated) &&
+	MERGE=$(git rev-parse --short rebase_i_merge) &&
+	ONTO=$(git rev-parse --short main) &&
+	test_when_finished "git rebase --abort" &&
+	FAKE_LINES="1 2 3 5 6 7 8 9 10 11 4" &&
+	export FAKE_LINES &&
+	test_must_fail git rebase -ir main &&
+	cat >expect <<EOF &&
+interactive rebase in progress; onto $ONTO
+Last commands done (8 commands done):
+   pick $PICK side1
+   merge -C $MERGE rebase-i-merge-side # Merge branch '\''rebase_i_merge_side'\'' into rebase_i_merge
+  (see more in file .git/rebase-merge/done)
+Next command to do (1 remaining command):
+   pick $UNRELATED unrelated
+  (use "git rebase --edit-todo" to view and edit)
+You are currently rebasing branch '\''rebase_i_merge'\'' on '\''$ONTO'\''.
+  (fix conflicts and then run "git rebase --continue")
+  (use "git rebase --skip" to skip this patch)
+  (use "git rebase --abort" to check out the original branch)
+
+Unmerged paths:
+  (use "git add <file>..." to mark resolution)
+	both modified:   main.txt
+
+no changes added to commit (use "git add" and/or "git commit -a")
+EOF
+	git status --untracked-files=no >actual &&
+	test_cmp expect actual
+'
+
 
 test_expect_success 'status when rebasing -i in edit mode' '
 	git reset --hard main &&
diff --git a/wt-status.c b/wt-status.c
index d11d9f9f142..f15495039e3 100644
--- a/wt-status.c
+++ b/wt-status.c
@@ -1744,6 +1744,7 @@  int wt_status_check_rebase(const struct worktree *wt,
 			   struct wt_status_state *state)
 {
 	struct stat st;
+	struct string_list have_done = STRING_LIST_INIT_DUP;
 
 	if (!stat(worktree_git_path(the_repository, wt, "rebase-apply"), &st)) {
 		if (!stat(worktree_git_path(the_repository, wt, "rebase-apply/applying"), &st)) {
@@ -1760,8 +1761,12 @@  int wt_status_check_rebase(const struct worktree *wt,
 			state->rebase_interactive_in_progress = 1;
 		else
 			state->rebase_in_progress = 1;
+		read_rebase_todolist("rebase-merge/done", &have_done);
+		if (have_done.nr > 0 && starts_with(have_done.items[have_done.nr - 1].string, "merge"))
+				state->merge_during_rebase_in_progress = 1;
 		state->branch = get_branch(wt, "rebase-merge/head-name");
 		state->onto = get_branch(wt, "rebase-merge/onto");
+		string_list_clear(&have_done, 0);
 	} else
 		return 0;
 	return 1;
@@ -1855,10 +1860,15 @@  static void wt_longstatus_print_state(struct wt_status *s)
 
 	if (state->merge_in_progress) {
 		if (state->rebase_interactive_in_progress) {
-			show_rebase_information(s, state_color);
-			fputs("\n", s->fp);
-		}
-		show_merge_in_progress(s, state_color);
+			if (state->merge_during_rebase_in_progress)
+				show_rebase_in_progress(s, state_color);
+			else {
+				show_rebase_information(s, state_color);
+				fputs("\n", s->fp);
+				show_merge_in_progress(s, state_color);
+			}
+		} else
+			show_merge_in_progress(s, state_color);
 	} else if (state->am_in_progress)
 		show_am_in_progress(s, state_color);
 	else if (state->rebase_in_progress || state->rebase_interactive_in_progress)
diff --git a/wt-status.h b/wt-status.h
index 4e377ce62b8..84bedfcd48f 100644
--- a/wt-status.h
+++ b/wt-status.h
@@ -87,6 +87,7 @@  struct wt_status_state {
 	int am_empty_patch;
 	int rebase_in_progress;
 	int rebase_interactive_in_progress;
+	int merge_during_rebase_in_progress;
 	int cherry_pick_in_progress;
 	int bisect_in_progress;
 	int revert_in_progress;