git@vger.kernel.org list mirror (unofficial, one of many)
 help / color / Atom feed
From: Johannes Schindelin <johannes.schindelin@gmx.de>
To: git@vger.kernel.org
Cc: Johannes Schindelin <johannes.schindelin@gmx.de>,
	Junio C Hamano <gitster@pobox.com>,
	Eric Sunshine <sunshine@sunshineco.com>,
	Stefan Beller <sbeller@google.com>,
	Phillip Wood <phillip.wood@dunelm.org.uk>
Subject: [PATCH v4 0/4] rebase -i: avoid stale "# This is a combination of" in commit messages
Date: Fri, 27 Apr 2018 22:48:13 +0200
Message-ID: <cover.1524862093.git.johannes.schindelin@gmx.de> (raw)
In-Reply-To: <CAPig+cRrS0_nYJJY=O6cboV630sNQHPV5QGrQdD8MW-sYzNFGQ@mail.gmail.com>

Eric Sunshine pointed out that I had such a commit message in
https://public-inbox.org/git/CAPig+cRrS0_nYJJY=O6cboV630sNQHPV5QGrQdD8MW-sYzNFGQ@mail.gmail.com/
and I went on a hunt to figure out how the heck this happened.

Turns out that if there is a fixup/squash chain where the *last* command
fails with merge conflicts, and we either --skip ahead or resolve the
conflict to a clean tree and then --continue, our code does not do a
final cleanup.

Contrary to my initial gut feeling, this bug was not introduced by my
rewrite in C of the core parts of rebase -i, but it looks to me as if
that bug was with us for a very long time (at least the --skip part).

The developer (read: user of rebase -i) in me says that we would want to
fast-track this, but the author of rebase -i in me says that we should
be cautious and cook this in `next` for a while.

Fixes since v3 (thanks, Phillip, for the really fruitful discussion!):

- We now avoid using the commit message prepared for the skipped
  fixup/squash.

- Replaced the "rebase -i: Handle "combination of <n> commits" with
  GETTEXT_POISON" patch by a *real* fix instead of a work-around: Instead
  of parsing the first line of the commit message and punting when it is
  missing an ASCII-encoded number, we determine <n> separately
  (independent from any localized text).

- Fixed quite a couple more corner cases, using the `current-fixups`
  file introduced for the GETTEXT_POISON fix:

  * we only need to re-commit if this was the final fixup/squash in the
    fixup/squash chain,

  * we only need to commit interactively if there was *any* non-skipped
    squash,

  * if the fixup/squash chain continues, the <N> was incorrect in the
    "This is a combination of <N> commits" comment in the intermediate
    commit message (it included the now-skipped commits), and

  * even if a filed fixup/squash in the middle of a fixup/squash chain
    failed, and its merge conflicts were resolved and committed, the
    "This is a combination of <N> commits" comment was incorrect: we
    had already deleted message-fixup and message-squash, so the next
    update_squash_message() would mistakenly assume that we were
    starting afresh. Worse: if only fixup commands were remaining, but
    there had been a squash command, we would retain the "squash!" line
    in the commit message and not give the user a chance to clean things
    up in the final fixup!


Johannes Schindelin (4):
  rebase -i: demonstrate bugs with fixup!/squash! commit messages
  rebase -i: Handle "combination of <n> commits" with GETTEXT_POISON
  sequencer: always commit without editing when asked for
  rebase --skip: clean up commit message after a failed fixup/squash

 sequencer.c                | 193 ++++++++++++++++++++++++++++---------
 sequencer.h                |   6 +-
 t/t3418-rebase-continue.sh |  49 ++++++++++
 3 files changed, 200 insertions(+), 48 deletions(-)


base-commit: 1f1cddd558b54bb0ce19c8ace353fd07b758510d
Published-As: https://github.com/dscho/git/releases/tag/clean-msg-after-fixup-continue-v4
Fetch-It-Via: git fetch https://github.com/dscho/git clean-msg-after-fixup-continue-v4

Interdiff vs v3:
 diff --git a/sequencer.c b/sequencer.c
 index e1efb0ebf31..cec180714ef 100644
 --- a/sequencer.c
 +++ b/sequencer.c
 @@ -74,13 +74,6 @@ static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
   * previous commit and from the first squash/fixup commit are written
   * to it. The commit message for each subsequent squash/fixup commit
   * is appended to the file as it is processed.
 - *
 - * The first line of the file is of the form
 - *     # This is a combination of $count commits.
 - * where $count is the number of commits whose messages have been
 - * written to the file so far (including the initial "pick" commit).
 - * Each time that a commit message is processed, this line is read and
 - * updated. It is deleted just before the combined commit is made.
   */
  static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
  /*
 @@ -91,6 +84,11 @@ static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
   * commit without opening the editor.)
   */
  static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
 +/*
 + * This file contains the list fixup/squash commands that have been
 + * accumulated into message-fixup or message-squash so far.
 + */
 +static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
  /*
   * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
   * GIT_AUTHOR_DATE that will be used for the commit that is currently
 @@ -106,13 +104,6 @@ static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
   * command is processed, this file is deleted.
   */
  static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
 -/*
 - * If there was a merge conflict in a fixup/squash series, we need to
 - * record the type so that a `git rebase --skip` can clean up the commit
 - * message as appropriate. This file will contain that type (`fixup` or
 - * `squash`), and not exist otherwise.
 - */
 -static GIT_PATH_FUNC(rebase_path_amend_type, "rebase-merge/amend-type")
  /*
   * When we stop at a given patch via the "edit" command, this file contains
   * the abbreviated commit name of the corresponding patch.
 @@ -260,6 +251,7 @@ int sequencer_remove_state(struct replay_opts *opts)
  	for (i = 0; i < opts->xopts_nr; i++)
  		free(opts->xopts[i]);
  	free(opts->xopts);
 +	strbuf_release(&opts->current_fixups);
  
  	strbuf_addstr(&dir, get_dir(opts));
  	remove_dir_recursively(&dir, 0);
 @@ -725,6 +717,8 @@ static int run_git_commit(const char *defmsg, struct replay_opts *opts,
  		argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
  	if (defmsg)
  		argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
 +	else if (!(flags & EDIT_MSG))
 +		argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
  	if ((flags & CLEANUP_MSG))
  		argv_array_push(&cmd.args, "--cleanup=strip");
  	if ((flags & EDIT_MSG))
 @@ -1336,33 +1330,23 @@ static int update_squash_messages(enum todo_command command,
  		struct commit *commit, struct replay_opts *opts)
  {
  	struct strbuf buf = STRBUF_INIT;
 -	int count, res;
 +	int res;
  	const char *message, *body;
  
 -	if (file_exists(rebase_path_squash_msg())) {
 +	if (opts->current_fixup_count > 0) {
  		struct strbuf header = STRBUF_INIT;
 -		char *eol, *p;
 +		char *eol;
  
 -		if (strbuf_read_file(&buf, rebase_path_squash_msg(), 2048) <= 0)
 +		if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
  			return error(_("could not read '%s'"),
  				rebase_path_squash_msg());
  
 -		p = buf.buf + 1;
 -		eol = strchrnul(buf.buf, '\n');
 -		if (buf.buf[0] != comment_line_char ||
 -		    (p += strcspn(p, "0123456789\n")) == eol)
 -			count = -1;
 -		else
 -			count = strtol(p, NULL, 10);
 +		eol = buf.buf[0] != comment_line_char ?
 +			buf.buf : strchrnul(buf.buf, '\n');
  
  		strbuf_addf(&header, "%c ", comment_line_char);
 -		if (count < 1)
 -			strbuf_addf(&header, _("This is a combination of "
 -					       "several commits."));
 -		else
 -			strbuf_addf(&header,
 -				    _("This is a combination of %d commits."),
 -				    ++count);
 +		strbuf_addf(&header, _("This is a combination of %d commits."),
 +			    opts->current_fixup_count + 2);
  		strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
  		strbuf_release(&header);
  	} else {
 @@ -1385,10 +1369,8 @@ static int update_squash_messages(enum todo_command command,
  				     rebase_path_fixup_msg());
  		}
  
 -		count = 2;
  		strbuf_addf(&buf, "%c ", comment_line_char);
 -		strbuf_addf(&buf, _("This is a combination of %d commits."),
 -			    count);
 +		strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
  		strbuf_addf(&buf, "\n%c ", comment_line_char);
  		strbuf_addstr(&buf, _("This is the 1st commit message:"));
  		strbuf_addstr(&buf, "\n\n");
 @@ -1405,22 +1387,14 @@ static int update_squash_messages(enum todo_command command,
  	if (command == TODO_SQUASH) {
  		unlink(rebase_path_fixup_msg());
  		strbuf_addf(&buf, "\n%c ", comment_line_char);
 -		if (count < 2)
 -			strbuf_addf(&buf, _("This is the next commit "
 -					    "message:"));
 -		else
 -			strbuf_addf(&buf, _("This is the commit message #%d:"),
 -				    count);
 +		strbuf_addf(&buf, _("This is the commit message #%d:"),
 +			    ++opts->current_fixup_count);
  		strbuf_addstr(&buf, "\n\n");
  		strbuf_addstr(&buf, body);
  	} else if (command == TODO_FIXUP) {
  		strbuf_addf(&buf, "\n%c ", comment_line_char);
 -		if (count < 2)
 -			strbuf_addf(&buf, _("The next commit message will be "
 -					    "skipped:"));
 -		else
 -			strbuf_addf(&buf, _("The commit message #%d will be "
 -					    "skipped:"), count);
 +		strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
 +			    ++opts->current_fixup_count);
  		strbuf_addstr(&buf, "\n\n");
  		strbuf_add_commented_lines(&buf, body, strlen(body));
  	} else
 @@ -1429,6 +1403,17 @@ static int update_squash_messages(enum todo_command command,
  
  	res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
  	strbuf_release(&buf);
 +
 +	if (!res) {
 +		strbuf_addf(&opts->current_fixups, "%s%s %s",
 +			    opts->current_fixups.len ? "\n" : "",
 +			    command_to_string(command),
 +			    oid_to_hex(&commit->object.oid));
 +		res = write_message(opts->current_fixups.buf,
 +				    opts->current_fixups.len,
 +				    rebase_path_current_fixups(), 0);
 +	}
 +
  	return res;
  }
  
 @@ -1691,6 +1676,9 @@ static int do_pick_commit(enum todo_command command, struct commit *commit,
  	if (!res && final_fixup) {
  		unlink(rebase_path_fixup_msg());
  		unlink(rebase_path_squash_msg());
 +		unlink(rebase_path_current_fixups());
 +		strbuf_reset(&opts->current_fixups);
 +		opts->current_fixup_count = 0;
  	}
  
  leave:
 @@ -2067,6 +2055,16 @@ static int read_populate_opts(struct replay_opts *opts)
  		read_strategy_opts(opts, &buf);
  		strbuf_release(&buf);
  
 +		if (read_oneliner(&opts->current_fixups,
 +				  rebase_path_current_fixups(), 1)) {
 +			const char *p = opts->current_fixups.buf;
 +			opts->current_fixup_count = 1;
 +			while ((p = strchr(p, '\n'))) {
 +				opts->current_fixup_count++;
 +				p++;
 +			}
 +		}
 +
  		return 0;
  	}
  
 @@ -2413,21 +2411,9 @@ static int error_with_patch(struct commit *commit,
  static int error_failed_squash(struct commit *commit,
  	struct replay_opts *opts, int subject_len, const char *subject)
  {
 -	const char *amend_type = "squash";
 -
 -	if (rename(rebase_path_squash_msg(), rebase_path_message()))
 -		return error(_("could not rename '%s' to '%s'"),
 +	if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
 +		return error(_("could not copy '%s' to '%s'"),
  			rebase_path_squash_msg(), rebase_path_message());
 -
 -	if (file_exists(rebase_path_fixup_msg())) {
 -		unlink(rebase_path_fixup_msg());
 -		amend_type = "fixup";
 -	}
 -	if (write_message(amend_type, strlen(amend_type),
 -		       rebase_path_amend_type(), 0))
 -		return error(_("could not write '%s'"),
 -			     rebase_path_amend_type());
 -
  	unlink(git_path_merge_msg());
  	if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
  		return error(_("could not copy '%s' to '%s'"),
 @@ -2604,7 +2590,6 @@ static int pick_commits(struct todo_list *todo_list, struct replay_opts *opts)
  			unlink(rebase_path_author_script());
  			unlink(rebase_path_stopped_sha());
  			unlink(rebase_path_amend());
 -			unlink(rebase_path_amend_type());
  			delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
  		}
  		if (item->command <= TODO_SQUASH) {
 @@ -2794,9 +2779,11 @@ static int continue_single_pick(void)
  	return run_command_v_opt(argv, RUN_GIT_CMD);
  }
  
 -static int commit_staged_changes(struct replay_opts *opts)
 +static int commit_staged_changes(struct replay_opts *opts,
 +				 struct todo_list *todo_list)
  {
 -	unsigned int flags = ALLOW_EMPTY | EDIT_MSG, is_fixup = 0, is_clean;
 +	unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
 +	unsigned int final_fixup = 0, is_clean;
  
  	if (has_unstaged_changes(1))
  		return error(_("cannot rebase: You have unstaged changes."));
 @@ -2819,21 +2806,69 @@ static int commit_staged_changes(struct replay_opts *opts)
  				       "working tree. Please, commit them\n"
  				       "first and then run 'git rebase "
  				       "--continue' again."));
 -		if (is_clean && !oidcmp(&head, &to_amend)) {
 -			strbuf_reset(&rev);
 +		/*
 +		 * When skipping a failed fixup/squash, we need to edit the
 +		 * commit message, the current fixup list and count, and if it
 +		 * was the last fixup/squash in the chain, we need to clean up
 +		 * the commit message and if there was a squash, let the user
 +		 * edit it.
 +		 */
 +		if (is_clean && !oidcmp(&head, &to_amend) &&
 +		    opts->current_fixup_count > 0 &&
 +		    file_exists(rebase_path_stopped_sha())) {
 +			const char *p = opts->current_fixups.buf;
 +			int len = opts->current_fixups.len;
 +
 +			opts->current_fixup_count--;
 +			if (!len)
 +				BUG("Incorrect current_fixups:\n%s", p);
 +			while (len && p[len - 1] != '\n')
 +				len--;
 +			strbuf_setlen(&opts->current_fixups, len);
 +			if (write_message(p, len, rebase_path_current_fixups(),
 +					  0) < 0)
 +				return error(_("could not write file: '%s'"),
 +					     rebase_path_current_fixups());
 +
  			/*
 -			 * Clean tree, but we may need to finalize a
 -			 * fixup/squash chain. A failed fixup/squash leaves the
 -			 * file amend-type in rebase-merge/; It is okay if that
 -			 * file is missing, in which case there is no such
 -			 * chain to finalize.
 +			 * If a fixup/squash in a fixup/squash chain failed, the
 +			 * commit message is already correct, no need to commit
 +			 * it again.
 +			 *
 +			 * Only if it is the final command in the fixup/squash
 +			 * chain, and only if the chain is longer than a single
 +			 * fixup/squash command (which was just skipped), do we
 +			 * actually need to re-commit with a cleaned up commit
 +			 * message.
  			 */
 -			read_oneliner(&rev, rebase_path_amend_type(), 0);
 -			if (!strcmp("squash", rev.buf))
 -				is_fixup = TODO_SQUASH;
 -			else if (!strcmp("fixup", rev.buf)) {
 -				is_fixup = TODO_FIXUP;
 -				flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
 +			if (opts->current_fixup_count > 0 &&
 +			    !is_fixup(peek_command(todo_list, 0))) {
 +				final_fixup = 1;
 +				/*
 +				 * If there was not a single "squash" in the
 +				 * chain, we only need to clean up the commit
 +				 * message, no need to bother the user with
 +				 * opening the commit message in the editor.
 +				 */
 +				if (!starts_with(p, "squash ") &&
 +				    !strstr(p, "\nsquash "))
 +					flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
 +			} else if (is_fixup(peek_command(todo_list, 0))) {
 +				/*
 +				 * We need to update the squash message to skip
 +				 * the latest commit message.
 +				 */
 +				struct commit *commit;
 +				const char *path = rebase_path_squash_msg();
 +
 +				if (parse_head(&commit) ||
 +				    !(p = get_commit_buffer(commit, NULL)) ||
 +				    write_message(p, strlen(p), path, 0)) {
 +					unuse_commit_buffer(commit, p);
 +					return error(_("could not write file: "
 +						       "'%s'"), path);
 +				}
 +				unuse_commit_buffer(commit, p);
  			}
  		}
  
 @@ -2841,18 +2876,32 @@ static int commit_staged_changes(struct replay_opts *opts)
  		flags |= AMEND_MSG;
  	}
  
 -	if (is_clean && !is_fixup) {
 +	if (is_clean) {
  		const char *cherry_pick_head = git_path_cherry_pick_head();
  
  		if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
  			return error(_("could not remove CHERRY_PICK_HEAD"));
 -		return 0;
 +		if (!final_fixup)
 +			return 0;
  	}
  
 -	if (run_git_commit(rebase_path_message(), opts, flags))
 +	if (run_git_commit(final_fixup ? NULL : rebase_path_message(),
 +			   opts, flags))
  		return error(_("could not commit staged changes."));
  	unlink(rebase_path_amend());
 -	unlink(rebase_path_amend_type());
 +	if (final_fixup) {
 +		unlink(rebase_path_fixup_msg());
 +		unlink(rebase_path_squash_msg());
 +	}
 +	if (opts->current_fixup_count > 0) {
 +		/*
 +		 * Whether final fixup or not, we just cleaned up the commit
 +		 * message...
 +		 */
 +		unlink(rebase_path_current_fixups());
 +		strbuf_reset(&opts->current_fixups);
 +		opts->current_fixup_count = 0;
 +	}
  	return 0;
  }
  
 @@ -2864,14 +2913,16 @@ int sequencer_continue(struct replay_opts *opts)
  	if (read_and_refresh_cache(opts))
  		return -1;
  
 +	if (read_populate_opts(opts))
 +		return -1;
  	if (is_rebase_i(opts)) {
 -		if (commit_staged_changes(opts))
 +		if ((res = read_populate_todo(&todo_list, opts)))
 +			goto release_todo_list;
 +		if (commit_staged_changes(opts, &todo_list))
  			return -1;
  	} else if (!file_exists(get_todo_path(opts)))
  		return continue_single_pick();
 -	if (read_populate_opts(opts))
 -		return -1;
 -	if ((res = read_populate_todo(&todo_list, opts)))
 +	else if ((res = read_populate_todo(&todo_list, opts)))
  		goto release_todo_list;
  
  	if (!is_rebase_i(opts)) {
 diff --git a/sequencer.h b/sequencer.h
 index e45b178dfc4..1898158c52d 100644
 --- a/sequencer.h
 +++ b/sequencer.h
 @@ -44,10 +44,14 @@ struct replay_opts {
  	char **xopts;
  	size_t xopts_nr, xopts_alloc;
  
 +	/* Used by fixup/squash */
 +	struct strbuf current_fixups;
 +	int current_fixup_count;
 +
  	/* Only used by REPLAY_NONE */
  	struct rev_info *revs;
  };
 -#define REPLAY_OPTS_INIT { -1 }
 +#define REPLAY_OPTS_INIT { .action = -1, .current_fixups = STRBUF_INIT }
  
  /* Call this to setup defaults before parsing command line options */
  void sequencer_init_config(struct replay_opts *opts);
 diff --git a/t/t3418-rebase-continue.sh b/t/t3418-rebase-continue.sh
 index 693f92409ec..03bf1b8a3b3 100755
 --- a/t/t3418-rebase-continue.sh
 +++ b/t/t3418-rebase-continue.sh
 @@ -95,19 +95,46 @@ test_expect_success '--skip after failed fixup cleans commit message' '
  	test_commit "fixup! wants-fixup" wants-fixup.t 1 wants-fixup-1 &&
  	test_commit "fixup! wants-fixup" wants-fixup.t 2 wants-fixup-2 &&
  	test_commit "fixup! wants-fixup" wants-fixup.t 3 wants-fixup-3 &&
 -	test_must_fail env FAKE_LINES="1 fixup 2 fixup 4" \
 +	test_must_fail env FAKE_LINES="1 fixup 2 squash 4" \
  		git rebase -i HEAD~4 &&
  
  	: now there is a conflict, and comments in the commit message &&
  	git show HEAD >out &&
 -	test_i18ngrep "This is a combination of" out &&
 +	grep "fixup! wants-fixup" out &&
  
  	: skip and continue &&
 -	git rebase --skip &&
 +	echo "cp \"\$1\" .git/copy.txt" | write_script copy-editor.sh &&
 +	(test_set_editor "$PWD/copy-editor.sh" && git rebase --skip) &&
 +
 +	: the user should not have had to edit the commit message &&
 +	test_path_is_missing .git/copy.txt &&
  
  	: now the comments in the commit message should have been cleaned up &&
  	git show HEAD >out &&
 -	test_i18ngrep ! "This is a combination of" out
 +	! grep "fixup! wants-fixup" out &&
 +
 +	: now, let us ensure that "squash" is handled correctly &&
 +	git reset --hard wants-fixup-3 &&
 +	test_must_fail env FAKE_LINES="1 squash 4 squash 2 squash 4" \
 +		git rebase -i HEAD~4 &&
 +
 +	: the first squash failed, but there are two more in the chain &&
 +	(test_set_editor "$PWD/copy-editor.sh" &&
 +	 test_must_fail git rebase --skip) &&
 +
 +	: not the final squash, no need to edit the commit message &&
 +	test_path_is_missing .git/copy.txt &&
 +
 +	: The first squash was skipped, therefore: &&
 +	git show HEAD >out &&
 +	test_i18ngrep "# This is a combination of 2 commits" out &&
 +
 +	(test_set_editor "$PWD/copy-editor.sh" && git rebase --skip) &&
 +	git show HEAD >out &&
 +	test_i18ngrep ! "# This is a combination" out &&
 +
 +	: Final squash failed, but there was still a squash &&
 +	test_i18ngrep "# This is a combination of 2 commits" .git/copy.txt
  '
  
  test_expect_success 'setup rerere database' '
-- 
2.17.0.windows.1.33.gfcbb1fa0445


  parent reply index

Thread overview: 412+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2018-01-18 15:35 [PATCH 0/8] rebase -i: offer to recreate merge commits Johannes Schindelin
2018-01-18 15:35 ` [PATCH 1/8] sequencer: introduce new commands to reset the revision Johannes Schindelin
2018-01-18 16:25   ` Jacob Keller
2018-01-18 21:13     ` Johannes Schindelin
2018-01-18 21:21       ` Jacob Keller
2018-01-18 21:24     ` Philip Oakley
2018-01-18 21:28       ` Jacob Keller
2018-01-29 20:28       ` Johannes Schindelin
2018-01-22 21:25     ` Junio C Hamano
2018-01-29 22:00       ` Johannes Schindelin
2018-01-19  8:59   ` Eric Sunshine
2018-01-24 22:01     ` Junio C Hamano
2018-01-29 20:55       ` Johannes Schindelin
2018-01-29 20:50     ` Johannes Schindelin
2018-01-30  7:12       ` Eric Sunshine
2018-01-19 12:24   ` [PATCH 1/8] sequencer: introduce new commands to resettherevision Phillip Wood
2018-01-19 18:55     ` Phillip Wood
2018-01-19 18:59       ` Jacob Keller
2018-01-29 21:25         ` Johannes Schindelin
2018-01-29 21:29           ` Johannes Schindelin
2018-01-29 21:23     ` Johannes Schindelin
2018-01-18 15:35 ` [PATCH 2/8] sequencer: introduce the `merge` command Johannes Schindelin
2018-01-18 16:31   ` Jacob Keller
2018-01-18 21:22     ` Johannes Schindelin
2018-01-18 21:26       ` Jacob Keller
2018-01-19  9:54   ` Eric Sunshine
2018-01-19 14:45   ` Phillip Wood
2018-01-20  9:18     ` Jacob Keller
2018-01-29 21:41       ` Johannes Schindelin
2018-01-31 13:48         ` Johannes Schindelin
2018-01-31 17:58           ` Phillip Wood
2018-02-01  6:40           ` Jacob Keller
2018-01-22 22:12   ` Junio C Hamano
2018-01-29 22:15     ` Johannes Schindelin
2018-01-18 15:35 ` [PATCH 3/8] sequencer: fast-forward merge commits, if possible Johannes Schindelin
2018-01-19 14:53   ` Phillip Wood
2018-01-23 19:12     ` Junio C Hamano
2018-01-24 10:32       ` Phillip Wood
2018-01-24 18:51         ` Junio C Hamano
2018-01-29 21:47     ` Johannes Schindelin
2018-01-23 18:51   ` Junio C Hamano
2018-01-29 22:18     ` Johannes Schindelin
2018-01-18 15:35 ` [PATCH 4/8] rebase-helper --make-script: introduce a flag to recreate merges Johannes Schindelin
2018-01-18 21:39   ` Philip Oakley
2018-01-19 10:34   ` Eric Sunshine
2018-01-23 20:13     ` Junio C Hamano
2018-01-29 21:07       ` Johannes Schindelin
2018-01-29 21:05     ` Johannes Schindelin
2018-01-23 20:03   ` Junio C Hamano
2018-01-29 22:37     ` Johannes Schindelin
2018-01-18 15:35 ` [PATCH 5/8] rebase: introduce the --recreate-merges option Johannes Schindelin
2018-01-19 10:55   ` Eric Sunshine
2018-01-29 21:09     ` Johannes Schindelin
2018-01-23 20:22   ` Junio C Hamano
2018-02-10 19:31     ` Johannes Schindelin
2018-02-07  6:16   ` Sergey Organov
2018-02-07  7:26     ` Jacob Keller
2018-02-07  9:47       ` Sergey Organov
2018-02-07  7:27     ` Johannes Sixt
2018-02-07 17:36     ` Johannes Schindelin
2018-02-07 22:58       ` Øyvind Rønningstad
2018-02-07 23:31         ` Junio C Hamano
2018-02-08 12:34           ` Johannes Schindelin
2018-02-14  5:41             ` Sergey Organov
2018-02-09  6:11       ` Sergey Organov
2018-02-09  7:13         ` Johannes Sixt
2018-02-11 10:16           ` Jacob Keller
2018-02-12  7:38           ` Sergey Organov
2018-02-09  6:50   ` Sergey Organov
2018-02-10 23:06     ` Johannes Schindelin
2018-02-12  4:58       ` Sergey Organov
2018-02-12 20:21         ` Johannes Schindelin
2018-02-13  6:44           ` Sergey Organov
2018-02-15  1:08             ` Johannes Schindelin
2018-02-15  4:28               ` Sergey Organov
2018-02-15 16:51                 ` Johannes Schindelin
2018-02-12  5:22       ` Sergey Organov
2018-02-12 20:39         ` Johannes Schindelin
2018-02-13  4:39           ` Jacob Keller
2018-02-13  7:15             ` Sergey Organov
2018-02-14  1:35               ` Jacob Keller
2018-02-15  1:14                 ` Johannes Schindelin
2018-02-15  4:35                   ` Sergey Organov
2018-02-15 16:50                     ` Johannes Schindelin
2018-02-13  6:43           ` Sergey Organov
2018-02-15  1:40             ` Johannes Schindelin
2018-01-18 15:35 ` [PATCH 6/8] sequencer: handle autosquash and post-rewrite for merge commands Johannes Schindelin
2018-01-18 16:43   ` Jacob Keller
2018-01-18 21:27     ` Johannes Schindelin
2018-01-18 21:29       ` Jacob Keller
2018-01-23 20:27     ` Junio C Hamano
2018-01-18 15:36 ` [PATCH 7/8] pull: accept --rebase=recreate to recreate the branch topology Johannes Schindelin
2018-01-18 15:36 ` [PATCH 8/8] rebase -i: introduce --recreate-merges=no-rebase-cousins Johannes Schindelin
2018-01-18 22:00   ` Philip Oakley
2018-01-29 20:42     ` Johannes Schindelin
2018-01-20  1:09   ` Eric Sunshine
2018-01-18 16:49 ` [PATCH 0/8] rebase -i: offer to recreate merge commits Jacob Keller
2018-01-18 18:36 ` [PATCH 9, 10/8] interactive rebase feedback Stefan Beller
2018-01-18 18:36   ` [PATCH 9/8] [DO NOT APPLY, but squash?] git-rebase--interactive: clarify arguments Stefan Beller
2018-01-18 21:18     ` Jacob Keller
2018-01-18 21:36     ` Johannes Schindelin
2018-01-18 21:58       ` Stefan Beller
2018-01-19 20:30       ` Junio C Hamano
2018-01-20  9:14         ` Jacob Keller
2018-01-29 17:02           ` Johannes Schindelin
2018-01-18 18:36   ` [PATCH 10/8] [DO NOT APPLY, but improve?] rebase--interactive: introduce "stop" command Stefan Beller
2018-01-18 21:20     ` Jacob Keller
2018-01-18 22:08       ` Philip Oakley
2018-01-18 22:09         ` Jacob Keller
2018-01-18 22:00     ` Johannes Schindelin
2018-01-18 22:09       ` Stefan Beller
2018-01-19 20:25 ` [PATCH 0/8] rebase -i: offer to recreate merge commits Junio C Hamano
2018-01-29 21:53   ` Johannes Schindelin
2018-01-23 20:29 ` Junio C Hamano
2018-01-29 22:53   ` Johannes Schindelin
2018-01-29 22:54 ` [PATCH v2 00/10] " Johannes Schindelin
2018-01-29 22:54   ` [PATCH v2 01/10] git-rebase--interactive: clarify arguments Johannes Schindelin
2018-01-29 22:54   ` [PATCH v2 02/10] sequencer: introduce new commands to reset the revision Johannes Schindelin
2018-01-30  8:06     ` Eric Sunshine
2018-02-10 20:58       ` Johannes Schindelin
2018-01-30 20:17     ` Stefan Beller
2018-01-31 13:21       ` Johannes Schindelin
2018-01-31 18:02         ` [PATCH v2 02/10] sequencer: introduce new commands to reset therevision Phillip Wood
2018-02-10 21:49           ` Johannes Schindelin
2018-01-29 22:54   ` [PATCH v2 03/10] sequencer: introduce the `merge` command Johannes Schindelin
2018-01-29 22:54   ` [PATCH v2 04/10] sequencer: fast-forward merge commits, if possible Johannes Schindelin
2018-01-29 22:54   ` [PATCH v2 05/10] rebase-helper --make-script: introduce a flag to recreate merges Johannes Schindelin
2018-01-29 22:54   ` [PATCH v2 06/10] rebase: introduce the --recreate-merges option Johannes Schindelin
2018-01-29 22:54   ` [PATCH v2 07/10] sequencer: make refs generated by the `label` command worktree-local Johannes Schindelin
2018-01-29 22:55   ` [PATCH v2 08/10] sequencer: handle autosquash and post-rewrite for merge commands Johannes Schindelin
2018-01-29 22:55   ` [PATCH v2 09/10] pull: accept --rebase=recreate to recreate the branch topology Johannes Schindelin
2018-01-29 22:55   ` [PATCH v2 10/10] rebase -i: introduce --recreate-merges=[no-]rebase-cousins Johannes Schindelin
2018-01-30 18:47   ` [PATCH v2 00/10] rebase -i: offer to recreate merge commits Stefan Beller
2018-01-31 13:08     ` Johannes Schindelin
2018-01-30 21:36   ` Junio C Hamano
2018-01-31 13:29     ` Johannes Schindelin
2018-02-01  6:37       ` Jacob Keller
2018-02-11  0:09   ` [PATCH v3 00/12] " Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 01/12] sequencer: avoid using errno clobbered by rollback_lock_file() Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 02/12] sequencer: make rearrange_squash() a bit more obvious Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 03/12] git-rebase--interactive: clarify arguments Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 04/12] sequencer: introduce new commands to reset the revision Johannes Schindelin
2018-02-12 19:26       ` Eric Sunshine
2018-02-12 20:46         ` Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 05/12] sequencer: introduce the `merge` command Johannes Schindelin
2018-02-12  8:48       ` Eric Sunshine
2018-02-12 20:17         ` Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 06/12] sequencer: fast-forward merge commits, if possible Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 07/12] rebase-helper --make-script: introduce a flag to recreate merges Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 08/12] rebase: introduce the --recreate-merges option Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 09/12] sequencer: make refs generated by the `label` command worktree-local Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 10/12] sequencer: handle post-rewrite for merge commands Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 11/12] pull: accept --rebase=recreate to recreate the branch topology Johannes Schindelin
2018-02-11  0:10     ` [PATCH v3 12/12] rebase -i: introduce --recreate-merges=[no-]rebase-cousins Johannes Schindelin
2018-02-23 12:35     ` [PATCH v4 00/12] rebase -i: offer to recreate merge commits Johannes Schindelin
2018-02-23 12:35       ` [PATCH v4 01/12] sequencer: avoid using errno clobbered by rollback_lock_file() Johannes Schindelin
2018-02-23 12:36       ` [PATCH v4 02/12] sequencer: make rearrange_squash() a bit more obvious Johannes Schindelin
2018-02-23 12:36       ` [PATCH v4 03/12] git-rebase--interactive: clarify arguments Johannes Schindelin
2018-02-23 12:37       ` [PATCH v4 04/12] sequencer: introduce new commands to reset the revision Johannes Schindelin
2018-02-23 12:37       ` [PATCH v4 05/12] sequencer: introduce the `merge` command Johannes Schindelin
2018-02-23 12:37       ` [PATCH v4 06/12] sequencer: fast-forward merge commits, if possible Johannes Schindelin
2018-02-23 12:38       ` [PATCH v4 07/12] rebase-helper --make-script: introduce a flag to recreate merges Johannes Schindelin
2018-02-23 12:38       ` [PATCH v4 08/12] rebase: introduce the --recreate-merges option Johannes Schindelin
2018-02-23 12:38       ` [PATCH v4 09/12] sequencer: make refs generated by the `label` command worktree-local Johannes Schindelin
2018-02-23 12:39       ` [PATCH v4 10/12] sequencer: handle post-rewrite for merge commands Johannes Schindelin
2018-02-23 12:39       ` [PATCH v4 11/12] pull: accept --rebase=recreate to recreate the branch topology Johannes Schindelin
2018-02-23 12:39       ` [PATCH v4 12/12] rebase -i: introduce --recreate-merges=[no-]rebase-cousins Johannes Schindelin
2018-02-25 10:54       ` [PATCH v4 00/12] rebase -i: offer to recreate merge commits Jacob Keller
2018-02-26 20:49         ` Johannes Schindelin
2018-02-26 21:29     ` [PATCH v5 " Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 01/12] sequencer: avoid using errno clobbered by rollback_lock_file() Johannes Schindelin
2018-02-27 21:33         ` Martin Ågren
2018-03-02 20:33           ` Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 02/12] sequencer: make rearrange_squash() a bit more obvious Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 03/12] git-rebase--interactive: clarify arguments Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 04/12] sequencer: introduce new commands to reset the revision Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 05/12] sequencer: introduce the `merge` command Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 06/12] sequencer: fast-forward merge commits, if possible Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 07/12] rebase-helper --make-script: introduce a flag to recreate merges Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 08/12] rebase: introduce the --recreate-merges option Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 09/12] sequencer: make refs generated by the `label` command worktree-local Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 10/12] sequencer: handle post-rewrite for merge commands Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 11/12] pull: accept --rebase=recreate to recreate the branch topology Johannes Schindelin
2018-02-26 21:29       ` [PATCH v5 12/12] rebase -i: introduce --recreate-merges=[no-]rebase-cousins Johannes Schindelin
2018-03-06  4:02       ` [PATCH v5 00/12] rebase -i: offer to recreate merge commits Igor Djordjevic
2018-03-07 13:50         ` Johannes Schindelin
2018-04-10 12:29       ` [PATCH v6 00/15] rebase -i: offer to recreate commit topology Johannes Schindelin
2018-04-10 12:29         ` [PATCH v6 01/15] sequencer: avoid using errno clobbered by rollback_lock_file() Johannes Schindelin
2018-04-10 12:29         ` [PATCH v6 02/15] sequencer: make rearrange_squash() a bit more obvious Johannes Schindelin
2018-04-10 12:29         ` [PATCH v6 03/15] git-rebase--interactive: clarify arguments Johannes Schindelin
2018-04-10 12:29         ` [PATCH v6 04/15] sequencer: introduce new commands to reset the revision Johannes Schindelin
2018-04-11  6:17           ` Sergey Organov
2018-04-11 11:36             ` Johannes Schindelin
2018-04-11 16:07               ` Sergey Organov
2018-04-13 10:03           ` Phillip Wood
2018-04-15 17:17             ` Philip Oakley
2018-04-18 18:00               ` Phillip Wood
2018-04-10 12:29         ` [PATCH v6 05/15] sequencer: introduce the `merge` command Johannes Schindelin
2018-04-13 10:12           ` Phillip Wood
2018-04-13 17:57             ` Phillip Wood
2018-04-14  0:51               ` Johannes Schindelin
2018-04-18 18:04                 ` Phillip Wood
2018-04-19 12:03                 ` Johannes Schindelin
2018-04-10 12:29         ` [PATCH v6 06/15] sequencer: fast-forward `merge` commands, if possible Johannes Schindelin
2018-04-10 12:29         ` [PATCH v6 07/15] rebase-helper --make-script: introduce a flag to rebase merges Johannes Schindelin
2018-04-10 12:29         ` [PATCH v6 08/15] rebase: introduce the --rebase-merges option Johannes Schindelin
2018-04-10 12:30         ` [PATCH v6 09/15] rebase --rebase-merges: add test for --keep-empty Johannes Schindelin
2018-04-10 12:30         ` [PATCH v6 10/15] sequencer: make refs generated by the `label` command worktree-local Johannes Schindelin
2018-04-10 12:30         ` [PATCH v6 11/15] sequencer: handle post-rewrite for merge commands Johannes Schindelin
2018-04-10 12:30         ` [PATCH v6 12/15] rebase --rebase-merges: avoid "empty merges" Johannes Schindelin
2018-04-10 12:30         ` [PATCH v6 13/15] pull: accept --rebase=merges to recreate the branch topology Johannes Schindelin
2018-04-10 12:30         ` [PATCH v6 14/15] rebase -i: introduce --rebase-merges=[no-]rebase-cousins Johannes Schindelin
2018-04-12 11:30           ` Sergey Organov
2018-04-10 12:30         ` [PATCH v6 15/15] rebase -i --rebase-merges: add a section to the man page Johannes Schindelin
2018-04-10 18:49           ` Martin Ågren
2018-04-10 21:56             ` Johannes Schindelin
2018-04-11 15:35           ` Phillip Wood
2018-04-11 19:10             ` Eric Sunshine
2018-04-12  9:00               ` Johannes Schindelin
2018-04-13 15:21               ` Phillip Wood
2018-04-12  9:30             ` Johannes Schindelin
2018-04-12 18:29               ` Jacob Keller
2018-04-13 15:27               ` Phillip Wood
2018-04-12 11:52           ` Sergey Organov
2018-04-10 14:52         ` [PATCH v6 00/15] rebase -i: offer to recreate commit topology Sergey Organov
2018-04-10 22:11           ` Johannes Schindelin
2018-04-11  4:54             ` Sergey Organov
2018-04-11 11:28               ` Johannes Schindelin
2018-04-11 13:13                 ` Sergey Organov
2018-04-11 20:40                   ` Johannes Schindelin
2018-04-12  8:34                     ` Sergey Organov
2018-04-12 12:31                       ` Johannes Schindelin
2018-04-11 23:52                   ` Jacob Keller
2018-04-12  5:42                     ` Sergey Organov
2018-04-12 17:03                       ` Jacob Keller
2018-04-12 22:02                         ` Johannes Schindelin
2018-04-12 22:14                           ` Jacob Keller
2018-04-13 12:08                             ` Johannes Schindelin
2018-04-13 15:43                           ` Phillip Wood
2018-04-13 23:48                             ` Johannes Schindelin
2018-04-19  4:24                               ` Sergey Organov
2018-04-19  8:23                                 ` Jacob Keller
2018-04-19 11:28                                   ` Sergey Organov
2018-04-20  8:26                                   ` Johannes Schindelin
2018-04-20 20:39                                     ` Jacob Keller
2018-04-18  5:23                         ` Sergey Organov
2018-04-19 12:12         ` [PATCH v7 00/17] " Johannes Schindelin
2018-04-19 12:15           ` [PATCH v7 01/17] sequencer: avoid using errno clobbered by rollback_lock_file() Johannes Schindelin
2018-04-19 12:18           ` [PATCH v7 02/17] sequencer: make rearrange_squash() a bit more obvious Johannes Schindelin
2018-04-19 12:19           ` [PATCH v7 03/17] sequencer: refactor how original todo list lines are accessed Johannes Schindelin
2018-04-19 12:19           ` [PATCH v7 04/17] sequencer: offer helpful advice when a command was rescheduled Johannes Schindelin
2018-04-19 12:20           ` [PATCH v7 05/17] git-rebase--interactive: clarify arguments Johannes Schindelin
2018-04-19 12:20           ` [PATCH v7 06/17] sequencer: introduce new commands to reset the revision Johannes Schindelin
2018-04-20  9:39             ` Phillip Wood
2018-04-20 22:39               ` Johannes Schindelin
2018-04-19 12:20           ` [PATCH v7 07/17] # This is a combination of 2 commits. # This is the 1st commit message: Johannes Schindelin
2018-04-20  5:38             ` Eric Sunshine
2018-04-20  8:34               ` Johannes Schindelin
2018-04-20 21:06               ` [PATCH v2 0/4] rebase -i: avoid stale "# This is a combination of" in commit messages Johannes Schindelin
2018-04-20 21:07                 ` [PATCH v2 1/4] rebase -i: demonstrate bugs with fixup!/squash! " Johannes Schindelin
2018-04-20 21:07                 ` [PATCH v2 2/4] rebase -i: Handle "combination of <n> commits" with GETTEXT_POISON Johannes Schindelin
2018-04-20 21:16                   ` Stefan Beller
2018-04-21  7:20                     ` Johannes Schindelin
2018-04-20 21:07                 ` [PATCH v2 3/4] sequencer: leave a tell-tale when a fixup/squash failed Johannes Schindelin
2018-04-20 21:25                   ` Stefan Beller
2018-04-21  7:24                     ` Johannes Schindelin
2018-04-20 21:08                 ` [PATCH v2 4/4] rebase --skip: clean up commit message after a failed fixup/squash Johannes Schindelin
2018-04-21  7:34               ` [PATCH v3 0/4] rebase -i: avoid stale "# This is a combination of" in commit messages Johannes Schindelin
2018-04-21  7:35                 ` [PATCH v3 1/4] rebase -i: demonstrate bugs with fixup!/squash! " Johannes Schindelin
2018-04-21  7:35                 ` [PATCH v3 2/4] rebase -i: Handle "combination of <n> commits" with GETTEXT_POISON Johannes Schindelin
2018-04-21  7:35                 ` [PATCH v3 3/4] sequencer: leave a tell-tale when a fixup/squash failed Johannes Schindelin
2018-04-21  7:39                 ` [PATCH v3 4/4] rebase --skip: clean up commit message after a failed fixup/squash Johannes Schindelin
2018-04-23 18:11                 ` [PATCH v3 0/4] rebase -i: avoid stale "# This is a combination of" in commit messages Stefan Beller
2018-04-23 19:50                   ` [PATCH v3 0/4] rebase -i: avoid stale "# This is a combinationof" " Phillip Wood
2018-04-25 12:48                     ` Johannes Schindelin
2018-04-25 17:09                       ` Phillip Wood
2018-04-26  9:51                         ` Johannes Schindelin
2018-04-26 10:52                           ` Phillip Wood
2018-04-24  1:28                 ` [PATCH v3 0/4] rebase -i: avoid stale "# This is a combination of" " Junio C Hamano
2018-04-27 20:48               ` Johannes Schindelin [this message]
2018-04-27 20:48                 ` [PATCH v4 1/4] rebase -i: demonstrate bugs with fixup!/squash! " Johannes Schindelin
2018-04-27 20:48                 ` [PATCH v4 2/4] rebase -i: Handle "combination of <n> commits" with GETTEXT_POISON Johannes Schindelin
2018-04-27 20:48                 ` [PATCH v4 3/4] sequencer: always commit without editing when asked for Johannes Schindelin
2018-04-27 20:48                 ` [PATCH v4 4/4] rebase --skip: clean up commit message after a failed fixup/squash Johannes Schindelin
2018-04-27 21:28                   ` Stefan Beller
2018-04-28 13:05                     ` Johannes Schindelin
2018-05-06 17:50                   ` Phillip Wood
2018-05-09 10:50                     ` Phillip Wood
2018-10-02 13:50                     ` Johannes Schindelin
2018-10-08 13:37                       ` Phillip Wood
2018-04-19 12:21           ` [PATCH v7 08/17] sequencer: fast-forward `merge` commands, if possible Johannes Schindelin
2018-04-19 12:21           ` [PATCH v7 09/17] rebase-helper --make-script: introduce a flag to rebase merges Johannes Schindelin
2018-04-19 12:21           ` [PATCH v7 10/17] rebase: introduce the --rebase-merges option Johannes Schindelin
2018-04-19 12:22           ` [PATCH v7 11/17] rebase --rebase-merges: add test for --keep-empty Johannes Schindelin
2018-04-19 12:22           ` [PATCH v7 12/17] sequencer: make refs generated by the `label` command worktree-local Johannes Schindelin
2018-04-19 12:23           ` [PATCH v7 13/17] sequencer: handle post-rewrite for merge commands Johannes Schindelin
2018-04-19 12:23           ` [PATCH v7 14/17] rebase --rebase-merges: avoid "empty merges" Johannes Schindelin
2018-04-19 12:23           ` [PATCH v7 15/17] pull: accept --rebase=merges to recreate the branch topology Johannes Schindelin
2018-04-19 12:24           ` [PATCH v7 16/17] rebase -i: introduce --rebase-merges=[no-]rebase-cousins Johannes Schindelin
2018-04-19 12:24           ` [PATCH v7 17/17] rebase -i --rebase-merges: add a section to the man page Johannes Schindelin
2018-04-21 10:29           ` [PATCH v8 00/16] rebase -i: offer to recreate commit topology by rebasing merges Johannes Schindelin
2018-04-21 10:30             ` [PATCH v8 01/16] sequencer: avoid using errno clobbered by rollback_lock_file() Johannes Schindelin
2018-04-21 10:30             ` [PATCH v8 02/16] sequencer: make rearrange_squash() a bit more obvious Johannes Schindelin
2018-04-21 10:31             ` [PATCH v8 03/16] sequencer: refactor how original todo list lines are accessed Johannes Schindelin
2018-04-21 10:31             ` [PATCH v8 04/16] sequencer: offer helpful advice when a command was rescheduled Johannes Schindelin
2018-04-21 10:32             ` [PATCH v8 05/16] git-rebase--interactive: clarify arguments Johannes Schindelin
2018-04-21 10:33             ` [PATCH v8 06/16] sequencer: introduce the `merge` command Johannes Schindelin
2018-04-21 15:56               ` Phillip Wood
2018-04-22 17:17                 ` Phillip Wood
2018-04-23 12:22                   ` Johannes Schindelin
2018-04-23 12:20                 ` Johannes Schindelin
2018-04-23 15:54                   ` Phillip Wood
2018-04-24  5:13                     ` Martin Ågren
2018-04-24  5:13                       ` [PATCH 1/2] merge: setup `opts` later in `checkout_fast_forward()` Martin Ågren
2018-04-24  6:20                         ` Jacob Keller
2018-04-24  9:36                           ` Martin Ågren
2018-04-24 11:30                             ` Johannes Schindelin
2018-04-24  5:13                       ` [PATCH 2/2] unpack_trees_options: free messages when done Martin Ågren
2018-04-24 16:29                         ` Elijah Newren
2018-04-28 11:32                           ` Martin Ågren
2018-04-28 12:30                             ` Johannes Schindelin
2018-04-28 20:56                             ` Elijah Newren
2018-05-16 14:32                             ` Elijah Newren
2018-05-16 16:30                               ` [PATCH v2 0/3] " Martin Ågren
2018-05-16 16:30                                 ` [PATCH v2 1/3] merge: setup `opts` later in `checkout_fast_forward()` Martin Ågren
2018-05-16 16:41                                   ` Stefan Beller
2018-05-16 19:29                                     ` Martin Ågren
2018-05-16 21:21                                       ` Jacob Keller
2018-05-16 21:20                                     ` Jacob Keller
2018-05-17 21:48                                   ` Junio C Hamano
2018-05-18  1:59                                     ` Jacob Keller
2018-05-16 16:30                                 ` [PATCH v2 2/3] merge-recursive: provide pair of `unpack_trees_{start,finish}()` Martin Ågren
2018-05-16 16:31                                 ` [PATCH v2 3/3] unpack_trees_options: free messages when done Martin Ågren
2018-05-17 22:10                                   ` Junio C Hamano
2018-05-18  5:08                                     ` Martin Ågren
2018-05-18 21:23                                       ` [PATCH v3 0/3] " Martin Ågren
2018-05-18 21:23                                         ` [PATCH v3 1/3] merge: setup `opts` later in `checkout_fast_forward()` Martin Ågren
2018-05-18 21:23                                         ` [PATCH v3 2/3] merge-recursive: provide pair of `unpack_trees_{start,finish}()` Martin Ågren
2018-05-18 21:23                                         ` [PATCH v3 3/3] unpack_trees_options: free messages when done Martin Ågren
2018-05-18 21:33                                           ` Jeff King
2018-05-18 22:30                                             ` Elijah Newren
2018-05-19  1:02                                               ` Jeff King
2018-05-19  6:13                                                 ` Martin Ågren
2018-05-20 10:17                                                   ` [PATCH v4 0/4] " Martin Ågren
2018-05-20 10:17                                                     ` [PATCH v4 1/4] merge: setup `opts` later in `checkout_fast_forward()` Martin Ågren
2018-05-20 10:17                                                     ` [PATCH v4 2/4] merge-recursive: provide pair of `unpack_trees_{start,finish}()` Martin Ågren
2018-05-20 10:17                                                     ` [PATCH v4 3/4] string-list: provide `string_list_appendf()` Martin Ågren
2018-05-20 19:12                                                       ` Jacob Keller
2018-05-21  0:01                                                         ` Re*: " Junio C Hamano
2018-05-21  0:25                                                           ` Junio C Hamano
2018-05-21  2:39                                                             ` Jeff King
2018-05-21 14:54                                                             ` [PATCH v5 0/4] unpack_trees_options: free messages when done Martin Ågren
2018-05-21 14:54                                                               ` [PATCH v5 1/4] merge: setup `opts` later in `checkout_fast_forward()` Martin Ågren
2018-05-21 14:54                                                               ` [PATCH v5 2/4] merge-recursive: provide pair of `unpack_trees_{start,finish}()` Martin Ågren
2018-05-21 14:54                                                               ` [PATCH v5 3/4] argv-array: return the pushed string from argv_push*() Martin Ågren
2018-05-21 14:54                                                               ` [PATCH v5 4/4] unpack_trees_options: free messages when done Martin Ågren
2018-05-21 21:38                                                               ` [PATCH v5 0/4] " Jeff King
2018-05-22  2:46                                                               ` Junio C Hamano
2018-05-22  2:54                                                                 ` Junio C Hamano
2018-05-22 11:11                                                                   ` Martin Ågren
2018-05-23  0:48                                                                     ` Junio C Hamano
2018-05-21  2:38                                                           ` Re*: [PATCH v4 3/4] string-list: provide `string_list_appendf()` Jeff King
2018-05-20 10:17                                                     ` [PATCH v4 4/4] unpack_trees_options: free messages when done Martin Ågren
2018-05-16 21:54                                 ` [PATCH v2 0/3] " Elijah Newren
2018-05-17 12:09                                   ` Ben Peart
2018-04-24  8:22                       ` [PATCH v8 06/16] sequencer: introduce the `merge` command Johannes Schindelin
2018-04-22 12:01               ` Philip Oakley
2018-04-23 12:03                 ` Johannes Schindelin
2018-04-23 20:34                   ` Philip Oakley
2018-04-24  8:11                     ` Johannes Schindelin
2018-04-24 19:41                       ` Philip Oakley
2018-04-22 13:55               ` Philip Oakley
2018-04-21 10:33             ` [PATCH v8 07/16] sequencer: fast-forward `merge` commands, if possible Johannes Schindelin
2018-04-21 10:34             ` [PATCH v8 08/16] rebase-helper --make-script: introduce a flag to rebase merges Johannes Schindelin
2018-04-22 13:42               ` Philip Oakley
2018-04-24  8:33                 ` Johannes Schindelin
2018-04-21 10:34             ` [PATCH v8 09/16] rebase: introduce the --rebase-merges option Johannes Schindelin
2018-04-22 14:15               ` Philip Oakley
2018-04-24  5:01                 ` Junio C Hamano
2018-04-24  9:03                   ` Johannes Schindelin
2018-04-24  8:40                 ` Johannes Schindelin
2018-04-22 14:37               ` Philip Oakley
2018-04-24 10:52                 ` Johannes Schindelin
2018-04-21 10:35             ` [PATCH v8 10/16] rebase --rebase-merges: add test for --keep-empty Johannes Schindelin
2018-04-21 10:43             ` [PATCH v8 11/16] sequencer: make refs generated by the `label` command worktree-local Johannes Schindelin
2018-04-21 10:46             ` [PATCH v8 12/16] sequencer: handle post-rewrite for merge commands Johannes Schindelin
2018-04-21 10:47             ` [PATCH v8 13/16] rebase --rebase-merges: avoid "empty merges" Johannes Schindelin
2018-04-21 10:49             ` [PATCH v8 14/16] pull: accept --rebase=merges to recreate the branch topology Johannes Schindelin
2018-04-21 10:57             ` [PATCH v8 15/16] rebase -i: introduce --rebase-merges=[no-]rebase-cousins Johannes Schindelin
2018-04-21 11:09             ` [PATCH v8 16/16] rebase -i --rebase-merges: add a section to the man page Johannes Schindelin
2018-04-25 12:28             ` [PATCH v9 00/17] rebase -i: offer to recreate commit topology by rebasing merges Johannes Schindelin
2018-04-25 12:28               ` [PATCH v9 01/17] sequencer: avoid using errno clobbered by rollback_lock_file() Johannes Schindelin
2018-04-25 12:28               ` [PATCH v9 02/17] sequencer: make rearrange_squash() a bit more obvious Johannes Schindelin
2018-04-25 12:28               ` [PATCH v9 03/17] sequencer: refactor how original todo list lines are accessed Johannes Schindelin
2018-04-25 12:28               ` [PATCH v9 04/17] sequencer: offer helpful advice when a command was rescheduled Johannes Schindelin
2018-04-25 12:28               ` [PATCH v9 05/17] git-rebase--interactive: clarify arguments Johannes Schindelin
2018-04-25 12:28               ` [PATCH v9 06/17] sequencer: introduce new commands to reset the revision Johannes Schindelin
2018-04-25 12:28               ` [PATCH v9 07/17] sequencer: introduce the `merge` command Johannes Schindelin
2018-04-25 12:28               ` [PATCH v9 08/17] sequencer: fast-forward `merge` commands, if possible Johannes Schindelin
2018-04-25 12:29               ` [PATCH v9 09/17] rebase-helper --make-script: introduce a flag to rebase merges Johannes Schindelin
2018-04-25 12:29               ` [PATCH v9 10/17] rebase: introduce the --rebase-merges option Johannes Schindelin
2018-04-25 12:29               ` [PATCH v9 11/17] rebase --rebase-merges: add test for --keep-empty Johannes Schindelin
2018-04-25 12:29               ` [PATCH v9 12/17] sequencer: make refs generated by the `label` command worktree-local Johannes Schindelin
2018-04-25 12:29               ` [PATCH v9 13/17] sequencer: handle post-rewrite for merge commands Johannes Schindelin
2018-04-25 12:29               ` [PATCH v9 14/17] rebase --rebase-merges: avoid "empty merges" Johannes Schindelin
2018-04-25 12:29               ` [PATCH v9 15/17] pull: accept --rebase=merges to recreate the branch topology Johannes Schindelin
2018-04-25 12:29               ` [PATCH v9 16/17] rebase -i: introduce --rebase-merges=[no-]rebase-cousins Johannes Schindelin
2018-04-25 12:29               ` [PATCH v9 17/17] rebase -i --rebase-merges: add a section to the man page Johannes Schindelin
2018-04-26  3:51               ` [PATCH v9 00/17] rebase -i: offer to recreate commit topology by rebasing merges Junio C Hamano
2018-04-26  6:06                 ` Junio C Hamano
2018-05-25 14:19               ` Sergey Organov
2018-05-25 15:44                 ` Sergey Organov

Reply instructions:

You may reply publically to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

  List information: http://vger.kernel.org/majordomo-info.html

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=cover.1524862093.git.johannes.schindelin@gmx.de \
    --to=johannes.schindelin@gmx.de \
    --cc=git@vger.kernel.org \
    --cc=gitster@pobox.com \
    --cc=phillip.wood@dunelm.org.uk \
    --cc=sbeller@google.com \
    --cc=sunshine@sunshineco.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

git@vger.kernel.org list mirror (unofficial, one of many)

Archives are clonable:
	git clone --mirror https://public-inbox.org/git
	git clone --mirror http://ou63pmih66umazou.onion/git
	git clone --mirror http://czquwvybam4bgbro.onion/git
	git clone --mirror http://hjrcffqmbrq6wope.onion/git

Newsgroups are available over NNTP:
	nntp://news.public-inbox.org/inbox.comp.version-control.git
	nntp://ou63pmih66umazou.onion/inbox.comp.version-control.git
	nntp://czquwvybam4bgbro.onion/inbox.comp.version-control.git
	nntp://hjrcffqmbrq6wope.onion/inbox.comp.version-control.git
	nntp://news.gmane.org/gmane.comp.version-control.git

 note: .onion URLs require Tor: https://www.torproject.org/

AGPL code for this site: git clone https://public-inbox.org/ public-inbox