<feed xmlns='http://www.w3.org/2005/Atom'>
<title>git/git-rebase--interactive.sh, branch v1.7.8.2</title>
<subtitle>Mirror of https://git.kernel.org/pub/scm/git/git.git/
</subtitle>
<id>https://www.git.shady.money/git/atom?h=v1.7.8.2</id>
<link rel='self' href='https://www.git.shady.money/git/atom?h=v1.7.8.2'/>
<link rel='alternate' type='text/html' href='https://www.git.shady.money/git/'/>
<updated>2011-12-28T19:32:34Z</updated>
<entry>
<title>Merge branch 'aw/rebase-i-stop-on-failure-to-amend' into maint</title>
<updated>2011-12-28T19:32:34Z</updated>
<author>
<name>Junio C Hamano</name>
<email>gitster@pobox.com</email>
</author>
<published>2011-12-28T19:32:34Z</published>
<link rel='alternate' type='text/html' href='https://www.git.shady.money/git/commit/?id=d9d73b37f34e2e366357b99a6ac74a09681b0ab8'/>
<id>urn:sha1:d9d73b37f34e2e366357b99a6ac74a09681b0ab8</id>
<content type='text'>
* aw/rebase-i-stop-on-failure-to-amend:
  rebase -i: interrupt rebase when "commit --amend" failed during "reword"
</content>
</entry>
<entry>
<title>rebase -i: interrupt rebase when "commit --amend" failed during "reword"</title>
<updated>2011-11-30T19:30:53Z</updated>
<author>
<name>Andrew Wong</name>
<email>andrew.kw.w@gmail.com</email>
</author>
<published>2011-11-30T15:52:51Z</published>
<link rel='alternate' type='text/html' href='https://www.git.shady.money/git/commit/?id=0becb3e4b94f19358f66ec2f4bbbf89904251bf5'/>
<id>urn:sha1:0becb3e4b94f19358f66ec2f4bbbf89904251bf5</id>
<content type='text'>
"commit --amend" could fail in cases like the user empties the commit
message, or pre-commit failed.  When it fails, rebase should be
interrupted and alert the user, rather than ignoring the error and
continue on rebasing.  This also gives users a way to gracefully
interrupt a "reword" if they decided they actually want to do an "edit",
or even "rebase --abort".

Signed-off-by: Andrew Wong &lt;andrew.kw.w@gmail.com&gt;
Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
</content>
</entry>
<entry>
<title>"rebase -i": support special-purpose editor to edit insn sheet</title>
<updated>2011-10-17T21:40:07Z</updated>
<author>
<name>Peter Oberndorfer</name>
<email>kumbayo84@arcor.de</email>
</author>
<published>2011-10-17T20:26:23Z</published>
<link rel='alternate' type='text/html' href='https://www.git.shady.money/git/commit/?id=821881d88d3012a64a52ece9a8c2571ca00c35cd'/>
<id>urn:sha1:821881d88d3012a64a52ece9a8c2571ca00c35cd</id>
<content type='text'>
The insn sheet used by "rebase -i" is designed to be easily editable by
any text editor, but an editor that is specifically meant for it (but
is otherwise unsuitable for editing regular text files) could be useful
by allowing drag &amp; drop reordering in a GUI environment, for example.

The GIT_SEQUENCE_EDITOR environment variable and/or the sequence.editor
configuration variable can be used to specify such an editor, while
allowing the usual editor to be used to edit commit log messages. As
usual, the environment variable takes precedence over the configuration
variable.

It is envisioned that other "sequencer" based tools will use the same
mechanism.

Signed-off-by: Peter Oberndorfer &lt;kumbayo84@arcor.de&gt;
Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
</content>
</entry>
<entry>
<title>rebase -i: notice and warn if "exec $cmd" modifies the index or the working tree</title>
<updated>2011-08-26T22:25:41Z</updated>
<author>
<name>Junio C Hamano</name>
<email>gitster@pobox.com</email>
</author>
<published>2011-08-24T18:54:50Z</published>
<link rel='alternate' type='text/html' href='https://www.git.shady.money/git/commit/?id=1686519a0854ec09ee1cdd6db7f570ea4590dfce'/>
<id>urn:sha1:1686519a0854ec09ee1cdd6db7f570ea4590dfce</id>
<content type='text'>
If "exec $cmd" touched the index or the working tree, and exited with
non-zero status, the code did not check and warn that there now are
uncommitted changes.

Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
</content>
</entry>
<entry>
<title>rebase -i: clean error message for --continue after failed exec</title>
<updated>2011-08-26T21:57:09Z</updated>
<author>
<name>Matthieu Moy</name>
<email>Matthieu.Moy@imag.fr</email>
</author>
<published>2011-08-24T14:01:48Z</published>
<link rel='alternate' type='text/html' href='https://www.git.shady.money/git/commit/?id=ffaaed88aed2e9b7936a0c5b43c1b198db0dc2ab'/>
<id>urn:sha1:ffaaed88aed2e9b7936a0c5b43c1b198db0dc2ab</id>
<content type='text'>
After an "exec false" stops the rebase and gives the control back to
the user, if changes are added to the index, "rebase --continue" fails
with this message, which may technically be correct, but does not point
at the real problem:

.../git-rebase--interactive: line 774: .../.git/rebase-merge/author-script: No such file or directory

We could try auto-amending HEAD, but this goes against the logic of
.git/rebase-merge/author-script (see also the testcase 'auto-amend only
edited commits after "edit"' in t3404-rebase-interactive.sh) to
auto-amend something the user hasn't explicitely asked to edit.

Instead of doing anything automatically, detect the situation and give a
clean error message. While we're there, also clarify the error message in
case '. "$author_script"' fails, which now corresponds to really weird
senario where the author script exists but can't be read.

Test-case-by: Johannes Sixt &lt;j6t@kdbg.org&gt;
Signed-off-by: Matthieu Moy &lt;Matthieu.Moy@imag.fr&gt;
Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
</content>
</entry>
<entry>
<title>rebase -i -p: include non-first-parent commits in todo list</title>
<updated>2011-06-19T21:37:23Z</updated>
<author>
<name>Andrew Wong</name>
<email>andrew.kw.w@gmail.com</email>
</author>
<published>2011-06-18T22:12:01Z</published>
<link rel='alternate' type='text/html' href='https://www.git.shady.money/git/commit/?id=12bf828348922935b1d5ca10f2d829c9a64b6e41'/>
<id>urn:sha1:12bf828348922935b1d5ca10f2d829c9a64b6e41</id>
<content type='text'>
Consider this graph:

        D---E    (topic, HEAD)
       /   /
  A---B---C      (master)
   \
    F            (topic2)

and the following three commands:
  1. git rebase -i -p A
  2. git rebase -i -p --onto F A
  3. git rebase -i -p B

Currently, (1) and (2) will pick B, D, C, and E onto A and F,
respectively.  However, (3) will only pick D and E onto B, but not C,
which is inconsistent with (1) and (2).  As a result, we cannot modify C
during the interactive-rebase.

The current behavior also creates a bug if we do:
  4. git rebase -i -p C

In (4), E is never picked.  And since interactive-rebase resets "HEAD"
to "onto" before picking any commits, D and E are lost after the
interactive-rebase.

This patch fixes the inconsistency and bug by ensuring that all children
of upstream are always picked.  This essentially reverts the commit:
  d80d6bc146232d81f1bb4bc58e5d89263fd228d4

When compiling the todo list, commits reachable from "upstream" should
never be skipped under any conditions.  Otherwise, we lose the ability
to modify them like (3), and create a bug like (4).

Two of the tests contain a scenario like (3).  Since the new behavior
added more commits for picking, these tests need to be updated to
account for the additional pick lines.  A new test has also been added
for (4).

Signed-off-by: Andrew Wong &lt;andrew.kw.w@gmail.com&gt;
Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
</content>
</entry>
<entry>
<title>rebase: write a reflog entry when finishing</title>
<updated>2011-05-27T22:52:03Z</updated>
<author>
<name>Jeff King</name>
<email>peff@peff.net</email>
</author>
<published>2011-05-27T20:16:14Z</published>
<link rel='alternate' type='text/html' href='https://www.git.shady.money/git/commit/?id=53f2ffa80c1c5ea5feb9fbe7432bf7106cf3047e'/>
<id>urn:sha1:53f2ffa80c1c5ea5feb9fbe7432bf7106cf3047e</id>
<content type='text'>
When we finish a rebase, our detached HEAD is at the final
result. We update the original branch ref with this result,
and then point the HEAD symbolic ref at the updated branch.
We write a reflog for the branch update, but not for the
update of HEAD.

Because we're already at the final result on the detached
HEAD, moving to the branch actually doesn't change our
commit sha1 at all. So in that sense, a reflog entry would
be pointless.

However, humans do read reflogs, and an entry saying "rebase
finished: returning to refs/heads/master" can be helpful in
understanding what is going on.

Signed-off-by: Jeff King &lt;peff@peff.net&gt;
Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
</content>
</entry>
<entry>
<title>Merge branch 'aw/maint-rebase-i-p-no-ff'</title>
<updated>2011-05-06T17:50:00Z</updated>
<author>
<name>Junio C Hamano</name>
<email>gitster@pobox.com</email>
</author>
<published>2011-05-06T17:50:00Z</published>
<link rel='alternate' type='text/html' href='https://www.git.shady.money/git/commit/?id=9fdc1cc872308869d76665be55367eef48f05ff6'/>
<id>urn:sha1:9fdc1cc872308869d76665be55367eef48f05ff6</id>
<content type='text'>
* aw/maint-rebase-i-p-no-ff:
  git-rebase--interactive.sh: preserve-merges fails on merges created with no-ff

Conflicts:
	git-rebase--interactive.sh
</content>
</entry>
<entry>
<title>git-rebase--interactive.sh: preserve-merges fails on merges created with no-ff</title>
<updated>2011-04-28T16:56:55Z</updated>
<author>
<name>Andrew Wong</name>
<email>andrew.kw.w@gmail.com</email>
</author>
<published>2011-04-28T04:35:55Z</published>
<link rel='alternate' type='text/html' href='https://www.git.shady.money/git/commit/?id=c192f9c865dbdae48c0400d717581d34cd315fb8'/>
<id>urn:sha1:c192f9c865dbdae48c0400d717581d34cd315fb8</id>
<content type='text'>
'git rebase' uses 'git merge' to preserve merges (-p).  This preserves
the original merge commit correctly, except when the original merge
commit was created by 'git merge --no-ff'.  In this case, 'git rebase'
will fail to preserve the merge, because during 'git rebase', 'git
merge' will simply fast-forward and skip the commit.  For example:

               B
              / \
             A---M
            /
    ---o---O---P---Q

If we try to rebase M onto P, we lose the merge commit and this happens:

                 A---B
                /
    ---o---O---P---Q

To correct this, we simply do a "no fast-forward" on all merge commits
when rebasing.  Since by the time we decided to do a 'git merge' inside
'git rebase', it means there was a merge originally, so 'git merge'
should always create a merge commit regardless of what the merge
branches look like. This way, when rebase M onto P from the above
example, we get:

                   B
                  / \
                 A---M
                /
    ---o---O---P---Q

Signed-off-by: Andrew Wong &lt;andrew.kw.w@gmail.com&gt;
Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
</content>
</entry>
<entry>
<title>Makefile: do not install sourced rebase scripts</title>
<updated>2011-02-25T20:19:41Z</updated>
<author>
<name>Martin von Zweigbergk</name>
<email>martin.von.zweigbergk@gmail.com</email>
</author>
<published>2011-02-25T03:32:06Z</published>
<link rel='alternate' type='text/html' href='https://www.git.shady.money/git/commit/?id=fdb76c104af5196fe1faf6d84209daf752e87010'/>
<id>urn:sha1:fdb76c104af5196fe1faf6d84209daf752e87010</id>
<content type='text'>
When git-rebase.sh recently started sourcing
git-rebase--interactive.sh instead of executing it, executable bit of
the latter file should have been turned off and it should have been
moved from SCRIPT_SH to SCRIPT_LIB in the Makefile. Its two new
siblings, git-rebase--am.sh and git-rebase--merge.sh (whose executable
bits are already off) should also be moved to SCRIPT_LIB in the
Makefile.

Reported-by: Johannes Sixt &lt;j6t@kdbg.org&gt;
Helped-by: Jeff King &lt;peff@peff.net&gt;
Signed-off-by: Martin von Zweigbergk &lt;martin.von.zweigbergk@gmail.com&gt;
Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
</content>
</entry>
</feed>
