2005-06-25 09:23:43 +00:00
|
|
|
#!/bin/sh
|
|
|
|
#
|
|
|
|
# Copyright (c) 2005 Junio C Hamano.
|
|
|
|
#
|
|
|
|
|
2006-10-03 16:29:31 +00:00
|
|
|
USAGE='[-v] [--onto <newbase>] <upstream> [<branch>]'
|
2006-04-26 14:49:38 +00:00
|
|
|
LONG_USAGE='git-rebase replaces <branch> with a new branch of the
|
|
|
|
same name. When the --onto option is provided the new branch starts
|
|
|
|
out with a HEAD equal to <newbase>, otherwise it is equal to <upstream>
|
|
|
|
It then attempts to create a new commit for each commit from the original
|
|
|
|
<branch> that does not exist in the <upstream> branch.
|
2006-02-22 01:10:12 +00:00
|
|
|
|
2006-04-26 14:49:38 +00:00
|
|
|
It is possible that a merge failure will prevent this process from being
|
|
|
|
completely automatic. You will have to resolve any such merge failure
|
2006-05-14 03:34:08 +00:00
|
|
|
and run git rebase --continue. Another option is to bypass the commit
|
|
|
|
that caused the merge failure with git rebase --skip. To restore the
|
|
|
|
original <branch> and remove the .dotest working files, use the command
|
|
|
|
git rebase --abort instead.
|
2006-02-22 01:10:12 +00:00
|
|
|
|
2006-04-26 14:49:38 +00:00
|
|
|
Note that if <branch> is not specified on the command line, the
|
|
|
|
currently checked out branch is used. You must be in the top
|
|
|
|
directory of your project to start (or continue) a rebase.
|
2006-02-14 22:42:05 +00:00
|
|
|
|
2006-04-26 14:49:38 +00:00
|
|
|
Example: git-rebase master~1 topic
|
2006-02-14 22:42:05 +00:00
|
|
|
|
2006-04-26 14:49:38 +00:00
|
|
|
A---B---C topic A'\''--B'\''--C'\'' topic
|
|
|
|
/ --> /
|
|
|
|
D---E---F---G master D---E---F---G master
|
2006-02-14 22:42:05 +00:00
|
|
|
'
|
2007-01-12 20:52:03 +00:00
|
|
|
|
|
|
|
SUBDIRECTORY_OK=Yes
|
2005-11-24 08:12:11 +00:00
|
|
|
. git-sh-setup
|
2006-12-28 07:34:48 +00:00
|
|
|
set_reflog_action rebase
|
2006-12-31 04:32:38 +00:00
|
|
|
require_work_tree
|
2007-01-12 20:52:03 +00:00
|
|
|
cd_to_toplevel
|
2005-08-07 22:51:09 +00:00
|
|
|
|
2006-05-14 03:34:08 +00:00
|
|
|
RESOLVEMSG="
|
|
|
|
When you have resolved this problem run \"git rebase --continue\".
|
|
|
|
If you would prefer to skip this patch, instead run \"git rebase --skip\".
|
|
|
|
To restore the original branch and stop rebasing run \"git rebase --abort\".
|
|
|
|
"
|
2006-02-14 22:42:05 +00:00
|
|
|
unset newbase
|
2006-09-25 02:49:47 +00:00
|
|
|
strategy=recursive
|
2006-06-21 10:04:41 +00:00
|
|
|
do_merge=
|
|
|
|
dotest=$GIT_DIR/.dotest-merge
|
|
|
|
prec=4
|
2006-10-03 16:29:31 +00:00
|
|
|
verbose=
|
2007-02-08 13:57:08 +00:00
|
|
|
git_am_opt=
|
2006-06-21 10:04:41 +00:00
|
|
|
|
|
|
|
continue_merge () {
|
|
|
|
test -n "$prev_head" || die "prev_head must be defined"
|
|
|
|
test -d "$dotest" || die "$dotest directory does not exist"
|
|
|
|
|
|
|
|
unmerged=$(git-ls-files -u)
|
|
|
|
if test -n "$unmerged"
|
|
|
|
then
|
|
|
|
echo "You still have unmerged paths in your index"
|
|
|
|
echo "did you forget update-index?"
|
2006-06-28 09:11:06 +00:00
|
|
|
die "$RESOLVEMSG"
|
2006-06-21 10:04:41 +00:00
|
|
|
fi
|
|
|
|
|
2007-03-25 00:56:13 +00:00
|
|
|
if ! git-diff-index --quiet HEAD
|
2006-06-21 10:04:41 +00:00
|
|
|
then
|
2006-06-28 10:24:23 +00:00
|
|
|
if ! git-commit -C "`cat $dotest/current`"
|
|
|
|
then
|
|
|
|
echo "Commit failed, please do not call \"git commit\""
|
|
|
|
echo "directly, but instead do one of the following: "
|
|
|
|
die "$RESOLVEMSG"
|
|
|
|
fi
|
2006-06-25 01:29:48 +00:00
|
|
|
printf "Committed: %0${prec}d" $msgnum
|
2006-06-21 10:04:41 +00:00
|
|
|
else
|
2006-06-25 01:29:48 +00:00
|
|
|
printf "Already applied: %0${prec}d" $msgnum
|
2006-06-21 10:04:41 +00:00
|
|
|
fi
|
2006-06-25 01:29:48 +00:00
|
|
|
echo ' '`git-rev-list --pretty=oneline -1 HEAD | \
|
|
|
|
sed 's/^[a-f0-9]\+ //'`
|
2006-06-21 10:04:41 +00:00
|
|
|
|
|
|
|
prev_head=`git-rev-parse HEAD^0`
|
|
|
|
# save the resulting commit so we can read-tree on it later
|
|
|
|
echo "$prev_head" > "$dotest/prev_head"
|
|
|
|
|
|
|
|
# onto the next patch:
|
|
|
|
msgnum=$(($msgnum + 1))
|
2006-06-22 08:44:54 +00:00
|
|
|
echo "$msgnum" >"$dotest/msgnum"
|
2006-06-21 10:04:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
call_merge () {
|
2006-06-22 08:44:54 +00:00
|
|
|
cmt="$(cat $dotest/cmt.$1)"
|
2006-06-21 10:04:41 +00:00
|
|
|
echo "$cmt" > "$dotest/current"
|
2006-12-28 07:34:56 +00:00
|
|
|
hd=$(git-rev-parse --verify HEAD)
|
|
|
|
cmt_name=$(git-symbolic-ref HEAD)
|
|
|
|
msgnum=$(cat $dotest/msgnum)
|
|
|
|
end=$(cat $dotest/end)
|
|
|
|
eval GITHEAD_$cmt='"${cmt_name##refs/heads/}~$(($end - $msgnum))"'
|
|
|
|
eval GITHEAD_$hd='"$(cat $dotest/onto_name)"'
|
|
|
|
export GITHEAD_$cmt GITHEAD_$hd
|
|
|
|
git-merge-$strategy "$cmt^" -- "$hd" "$cmt"
|
2006-06-21 10:04:41 +00:00
|
|
|
rv=$?
|
|
|
|
case "$rv" in
|
|
|
|
0)
|
2006-12-28 07:34:56 +00:00
|
|
|
unset GITHEAD_$cmt GITHEAD_$hd
|
2006-06-25 01:29:48 +00:00
|
|
|
return
|
2006-06-21 10:04:41 +00:00
|
|
|
;;
|
|
|
|
1)
|
|
|
|
test -d "$GIT_DIR/rr-cache" && git-rerere
|
2006-06-28 09:11:06 +00:00
|
|
|
die "$RESOLVEMSG"
|
2006-06-21 10:04:41 +00:00
|
|
|
;;
|
|
|
|
2)
|
|
|
|
echo "Strategy: $rv $strategy failed, try another" 1>&2
|
2006-06-28 09:11:06 +00:00
|
|
|
die "$RESOLVEMSG"
|
2006-06-21 10:04:41 +00:00
|
|
|
;;
|
|
|
|
*)
|
|
|
|
die "Unknown exit code ($rv) from command:" \
|
|
|
|
"git-merge-$strategy $cmt^ -- HEAD $cmt"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
|
|
|
finish_rb_merge () {
|
|
|
|
rm -r "$dotest"
|
|
|
|
echo "All done."
|
|
|
|
}
|
|
|
|
|
2006-02-14 22:42:05 +00:00
|
|
|
while case "$#" in 0) break ;; esac
|
|
|
|
do
|
|
|
|
case "$1" in
|
2006-04-26 14:49:38 +00:00
|
|
|
--continue)
|
2007-03-25 00:56:13 +00:00
|
|
|
git-diff-files --quiet || {
|
|
|
|
echo "You must edit all merge conflicts and then"
|
2006-04-26 14:49:38 +00:00
|
|
|
echo "mark them as resolved using git update-index"
|
|
|
|
exit 1
|
2007-03-25 00:56:13 +00:00
|
|
|
}
|
2006-06-21 10:04:41 +00:00
|
|
|
if test -d "$dotest"
|
|
|
|
then
|
|
|
|
prev_head="`cat $dotest/prev_head`"
|
|
|
|
end="`cat $dotest/end`"
|
|
|
|
msgnum="`cat $dotest/msgnum`"
|
|
|
|
onto="`cat $dotest/onto`"
|
|
|
|
continue_merge
|
|
|
|
while test "$msgnum" -le "$end"
|
|
|
|
do
|
|
|
|
call_merge "$msgnum"
|
|
|
|
continue_merge
|
|
|
|
done
|
|
|
|
finish_rb_merge
|
|
|
|
exit
|
|
|
|
fi
|
2006-12-28 07:34:48 +00:00
|
|
|
git am --resolved --3way --resolvemsg="$RESOLVEMSG"
|
2006-05-14 03:34:08 +00:00
|
|
|
exit
|
|
|
|
;;
|
|
|
|
--skip)
|
2006-06-21 10:04:41 +00:00
|
|
|
if test -d "$dotest"
|
|
|
|
then
|
2006-12-08 21:29:56 +00:00
|
|
|
if test -d "$GIT_DIR/rr-cache"
|
|
|
|
then
|
|
|
|
git-rerere clear
|
|
|
|
fi
|
2006-06-25 01:29:49 +00:00
|
|
|
prev_head="`cat $dotest/prev_head`"
|
|
|
|
end="`cat $dotest/end`"
|
|
|
|
msgnum="`cat $dotest/msgnum`"
|
|
|
|
msgnum=$(($msgnum + 1))
|
|
|
|
onto="`cat $dotest/onto`"
|
|
|
|
while test "$msgnum" -le "$end"
|
|
|
|
do
|
|
|
|
call_merge "$msgnum"
|
|
|
|
continue_merge
|
|
|
|
done
|
|
|
|
finish_rb_merge
|
|
|
|
exit
|
2006-06-21 10:04:41 +00:00
|
|
|
fi
|
2006-12-28 07:34:48 +00:00
|
|
|
git am -3 --skip --resolvemsg="$RESOLVEMSG"
|
2006-04-26 14:49:38 +00:00
|
|
|
exit
|
|
|
|
;;
|
|
|
|
--abort)
|
2006-12-08 21:29:56 +00:00
|
|
|
if test -d "$GIT_DIR/rr-cache"
|
|
|
|
then
|
|
|
|
git-rerere clear
|
|
|
|
fi
|
2006-06-21 10:04:41 +00:00
|
|
|
if test -d "$dotest"
|
|
|
|
then
|
|
|
|
rm -r "$dotest"
|
|
|
|
elif test -d .dotest
|
|
|
|
then
|
|
|
|
rm -r .dotest
|
|
|
|
else
|
|
|
|
die "No rebase in progress?"
|
|
|
|
fi
|
2006-04-26 14:49:38 +00:00
|
|
|
git reset --hard ORIG_HEAD
|
|
|
|
exit
|
|
|
|
;;
|
2006-02-14 22:42:05 +00:00
|
|
|
--onto)
|
|
|
|
test 2 -le "$#" || usage
|
|
|
|
newbase="$2"
|
|
|
|
shift
|
|
|
|
;;
|
2006-06-21 10:04:41 +00:00
|
|
|
-M|-m|--m|--me|--mer|--merg|--merge)
|
|
|
|
do_merge=t
|
|
|
|
;;
|
|
|
|
-s=*|--s=*|--st=*|--str=*|--stra=*|--strat=*|--strate=*|\
|
|
|
|
--strateg=*|--strategy=*|\
|
|
|
|
-s|--s|--st|--str|--stra|--strat|--strate|--strateg|--strategy)
|
|
|
|
case "$#,$1" in
|
|
|
|
*,*=*)
|
2006-06-27 16:54:26 +00:00
|
|
|
strategy=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
|
2006-06-21 10:04:41 +00:00
|
|
|
1,*)
|
|
|
|
usage ;;
|
|
|
|
*)
|
|
|
|
strategy="$2"
|
|
|
|
shift ;;
|
|
|
|
esac
|
|
|
|
do_merge=t
|
|
|
|
;;
|
2006-10-03 16:29:31 +00:00
|
|
|
-v|--verbose)
|
|
|
|
verbose=t
|
|
|
|
;;
|
2007-02-08 13:57:08 +00:00
|
|
|
-C*)
|
|
|
|
git_am_opt=$1
|
|
|
|
shift
|
|
|
|
;;
|
2006-02-14 22:42:05 +00:00
|
|
|
-*)
|
|
|
|
usage
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
break
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
shift
|
|
|
|
done
|
2005-12-14 11:11:37 +00:00
|
|
|
|
2005-11-28 21:00:31 +00:00
|
|
|
# Make sure we do not have .dotest
|
2006-06-21 10:04:41 +00:00
|
|
|
if test -z "$do_merge"
|
2005-11-28 21:00:31 +00:00
|
|
|
then
|
2006-06-21 10:04:41 +00:00
|
|
|
if mkdir .dotest
|
|
|
|
then
|
|
|
|
rmdir .dotest
|
|
|
|
else
|
|
|
|
echo >&2 '
|
2005-11-28 21:00:31 +00:00
|
|
|
It seems that I cannot create a .dotest directory, and I wonder if you
|
|
|
|
are in the middle of patch application or another rebase. If that is not
|
|
|
|
the case, please rm -fr .dotest and run me again. I am stopping in case
|
|
|
|
you still have something valuable there.'
|
2006-06-21 10:04:41 +00:00
|
|
|
exit 1
|
|
|
|
fi
|
|
|
|
else
|
|
|
|
if test -d "$dotest"
|
|
|
|
then
|
|
|
|
die "previous dotest directory $dotest still exists." \
|
|
|
|
'try git-rebase < --continue | --abort >'
|
|
|
|
fi
|
2005-11-28 21:00:31 +00:00
|
|
|
fi
|
|
|
|
|
Rewrite rebase to use git-format-patch piped to git-am.
The current rebase implementation finds commits in our tree but
not in the upstream tree using git-cherry, and tries to apply
them using git-cherry-pick (i.e. always use 3-way) one by one.
Which is fine, but when some of the changes do not apply
cleanly, it punts, and punts badly.
Suppose you have commits A-B-C-D-E since you forked from the
upstream and submitted the changes for inclusion. You fetch
from upstream head U and find that B has been picked up. You
run git-rebase to update your branch, which tries to apply
changes contained in A-C-D-E, in this order, but replaying of C
fails, because the upstream got changes that touch the same area
from elsewhere.
Now what?
It notes that fact, and goes ahead to apply D and E, and at the
very end tells you to deal with C by hand. Even if you somehow
managed to replay C on top of the result, you would now end up
with ...-B-...-U-A-D-E-C.
Breaking the order between B and others was the conscious
decision made by the upstream, so we would not worry about it,
and even if it were worrisome, it is too late for us to fix now.
What D and E do may well depend on having C applied before them,
which is a problem for us.
This rewrites rebase to use git-format-patch piped to git-am,
and when the patch does not apply, have git-am fall back on
3-way merge. The updated diff/patch pair knows how to apply
trivial binary patches as long as the pre- and post-images are
locally available, so this should work on a repository with
binary files as well.
The primary benefit of this change is that it makes rebase
easier to use when some of the changes do not replay cleanly.
In the "unapplicable patch in the middle" case, this "rebase"
works like this:
- A series of patches in e-mail form is created that records
what A-C-D-E do, and is fed to git-am. This is stored in
.dotest/ directory, just like the case you tried to apply
them from your mailbox. Your branch is rewound to the tip of
upstream U, and the original head is kept in .git/ORIG_HEAD,
so you could "git reset --hard ORIG_HEAD" in case the end
result is really messy.
- Patch A applies cleanly. This could either be a clean patch
application on top of rewound head (i.e. same as upstream
head), or git-am might have internally fell back on 3-way
(i.e. it would have done the same thing as git-cherry-pick).
In either case, a rebased commit A is made on top of U.
- Patch C does not apply. git-am stops here, with conflicts to
be resolved in the working tree. Yet-to-be-applied D and E
are still kept in .dotest/ directory at this point. What the
user does is exactly the same as fixing up unapplicable patch
when running git-am:
- Resolve conflict just like any merge conflicts.
- "git am --resolved --3way" to continue applying the patches.
- This applies the fixed-up patch so by definition it had
better apply. "git am" knows the patch after the fixed-up
one is D and then E; it applies them, and you will get the
changes from A-C-D-E commits on top of U, in this order.
I've been using this without noticing any problem, and as people
may know I do a lot of rebases.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-14 08:41:53 +00:00
|
|
|
# The tree must be really really clean.
|
2005-09-08 00:26:23 +00:00
|
|
|
git-update-index --refresh || exit
|
Rewrite rebase to use git-format-patch piped to git-am.
The current rebase implementation finds commits in our tree but
not in the upstream tree using git-cherry, and tries to apply
them using git-cherry-pick (i.e. always use 3-way) one by one.
Which is fine, but when some of the changes do not apply
cleanly, it punts, and punts badly.
Suppose you have commits A-B-C-D-E since you forked from the
upstream and submitted the changes for inclusion. You fetch
from upstream head U and find that B has been picked up. You
run git-rebase to update your branch, which tries to apply
changes contained in A-C-D-E, in this order, but replaying of C
fails, because the upstream got changes that touch the same area
from elsewhere.
Now what?
It notes that fact, and goes ahead to apply D and E, and at the
very end tells you to deal with C by hand. Even if you somehow
managed to replay C on top of the result, you would now end up
with ...-B-...-U-A-D-E-C.
Breaking the order between B and others was the conscious
decision made by the upstream, so we would not worry about it,
and even if it were worrisome, it is too late for us to fix now.
What D and E do may well depend on having C applied before them,
which is a problem for us.
This rewrites rebase to use git-format-patch piped to git-am,
and when the patch does not apply, have git-am fall back on
3-way merge. The updated diff/patch pair knows how to apply
trivial binary patches as long as the pre- and post-images are
locally available, so this should work on a repository with
binary files as well.
The primary benefit of this change is that it makes rebase
easier to use when some of the changes do not replay cleanly.
In the "unapplicable patch in the middle" case, this "rebase"
works like this:
- A series of patches in e-mail form is created that records
what A-C-D-E do, and is fed to git-am. This is stored in
.dotest/ directory, just like the case you tried to apply
them from your mailbox. Your branch is rewound to the tip of
upstream U, and the original head is kept in .git/ORIG_HEAD,
so you could "git reset --hard ORIG_HEAD" in case the end
result is really messy.
- Patch A applies cleanly. This could either be a clean patch
application on top of rewound head (i.e. same as upstream
head), or git-am might have internally fell back on 3-way
(i.e. it would have done the same thing as git-cherry-pick).
In either case, a rebased commit A is made on top of U.
- Patch C does not apply. git-am stops here, with conflicts to
be resolved in the working tree. Yet-to-be-applied D and E
are still kept in .dotest/ directory at this point. What the
user does is exactly the same as fixing up unapplicable patch
when running git-am:
- Resolve conflict just like any merge conflicts.
- "git am --resolved --3way" to continue applying the patches.
- This applies the fixed-up patch so by definition it had
better apply. "git am" knows the patch after the fixed-up
one is D and then E; it applies them, and you will get the
changes from A-C-D-E commits on top of U, in this order.
I've been using this without noticing any problem, and as people
may know I do a lot of rebases.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-14 08:41:53 +00:00
|
|
|
diff=$(git-diff-index --cached --name-status -r HEAD)
|
2005-12-14 23:36:35 +00:00
|
|
|
case "$diff" in
|
2007-01-31 16:12:03 +00:00
|
|
|
?*) echo "cannot rebase: your index is not up-to-date"
|
|
|
|
echo "$diff"
|
Rewrite rebase to use git-format-patch piped to git-am.
The current rebase implementation finds commits in our tree but
not in the upstream tree using git-cherry, and tries to apply
them using git-cherry-pick (i.e. always use 3-way) one by one.
Which is fine, but when some of the changes do not apply
cleanly, it punts, and punts badly.
Suppose you have commits A-B-C-D-E since you forked from the
upstream and submitted the changes for inclusion. You fetch
from upstream head U and find that B has been picked up. You
run git-rebase to update your branch, which tries to apply
changes contained in A-C-D-E, in this order, but replaying of C
fails, because the upstream got changes that touch the same area
from elsewhere.
Now what?
It notes that fact, and goes ahead to apply D and E, and at the
very end tells you to deal with C by hand. Even if you somehow
managed to replay C on top of the result, you would now end up
with ...-B-...-U-A-D-E-C.
Breaking the order between B and others was the conscious
decision made by the upstream, so we would not worry about it,
and even if it were worrisome, it is too late for us to fix now.
What D and E do may well depend on having C applied before them,
which is a problem for us.
This rewrites rebase to use git-format-patch piped to git-am,
and when the patch does not apply, have git-am fall back on
3-way merge. The updated diff/patch pair knows how to apply
trivial binary patches as long as the pre- and post-images are
locally available, so this should work on a repository with
binary files as well.
The primary benefit of this change is that it makes rebase
easier to use when some of the changes do not replay cleanly.
In the "unapplicable patch in the middle" case, this "rebase"
works like this:
- A series of patches in e-mail form is created that records
what A-C-D-E do, and is fed to git-am. This is stored in
.dotest/ directory, just like the case you tried to apply
them from your mailbox. Your branch is rewound to the tip of
upstream U, and the original head is kept in .git/ORIG_HEAD,
so you could "git reset --hard ORIG_HEAD" in case the end
result is really messy.
- Patch A applies cleanly. This could either be a clean patch
application on top of rewound head (i.e. same as upstream
head), or git-am might have internally fell back on 3-way
(i.e. it would have done the same thing as git-cherry-pick).
In either case, a rebased commit A is made on top of U.
- Patch C does not apply. git-am stops here, with conflicts to
be resolved in the working tree. Yet-to-be-applied D and E
are still kept in .dotest/ directory at this point. What the
user does is exactly the same as fixing up unapplicable patch
when running git-am:
- Resolve conflict just like any merge conflicts.
- "git am --resolved --3way" to continue applying the patches.
- This applies the fixed-up patch so by definition it had
better apply. "git am" knows the patch after the fixed-up
one is D and then E; it applies them, and you will get the
changes from A-C-D-E commits on top of U, in this order.
I've been using this without noticing any problem, and as people
may know I do a lot of rebases.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-14 08:41:53 +00:00
|
|
|
exit 1
|
|
|
|
;;
|
|
|
|
esac
|
2005-08-17 22:19:57 +00:00
|
|
|
|
2006-02-14 22:42:05 +00:00
|
|
|
# The upstream head must be given. Make sure it is valid.
|
|
|
|
upstream_name="$1"
|
|
|
|
upstream=`git rev-parse --verify "${upstream_name}^0"` ||
|
2006-02-21 20:56:14 +00:00
|
|
|
die "invalid upstream $upstream_name"
|
2005-12-14 23:36:35 +00:00
|
|
|
|
2007-03-22 09:54:59 +00:00
|
|
|
# Make sure the branch to rebase onto is valid.
|
|
|
|
onto_name=${newbase-"$upstream_name"}
|
|
|
|
onto=$(git-rev-parse --verify "${onto_name}^0") || exit
|
|
|
|
|
2006-02-13 07:17:04 +00:00
|
|
|
# If a hook exists, give it a chance to interrupt
|
|
|
|
if test -x "$GIT_DIR/hooks/pre-rebase"
|
|
|
|
then
|
|
|
|
"$GIT_DIR/hooks/pre-rebase" ${1+"$@"} || {
|
|
|
|
echo >&2 "The pre-rebase hook refused to rebase."
|
|
|
|
exit 1
|
|
|
|
}
|
|
|
|
fi
|
|
|
|
|
Rewrite rebase to use git-format-patch piped to git-am.
The current rebase implementation finds commits in our tree but
not in the upstream tree using git-cherry, and tries to apply
them using git-cherry-pick (i.e. always use 3-way) one by one.
Which is fine, but when some of the changes do not apply
cleanly, it punts, and punts badly.
Suppose you have commits A-B-C-D-E since you forked from the
upstream and submitted the changes for inclusion. You fetch
from upstream head U and find that B has been picked up. You
run git-rebase to update your branch, which tries to apply
changes contained in A-C-D-E, in this order, but replaying of C
fails, because the upstream got changes that touch the same area
from elsewhere.
Now what?
It notes that fact, and goes ahead to apply D and E, and at the
very end tells you to deal with C by hand. Even if you somehow
managed to replay C on top of the result, you would now end up
with ...-B-...-U-A-D-E-C.
Breaking the order between B and others was the conscious
decision made by the upstream, so we would not worry about it,
and even if it were worrisome, it is too late for us to fix now.
What D and E do may well depend on having C applied before them,
which is a problem for us.
This rewrites rebase to use git-format-patch piped to git-am,
and when the patch does not apply, have git-am fall back on
3-way merge. The updated diff/patch pair knows how to apply
trivial binary patches as long as the pre- and post-images are
locally available, so this should work on a repository with
binary files as well.
The primary benefit of this change is that it makes rebase
easier to use when some of the changes do not replay cleanly.
In the "unapplicable patch in the middle" case, this "rebase"
works like this:
- A series of patches in e-mail form is created that records
what A-C-D-E do, and is fed to git-am. This is stored in
.dotest/ directory, just like the case you tried to apply
them from your mailbox. Your branch is rewound to the tip of
upstream U, and the original head is kept in .git/ORIG_HEAD,
so you could "git reset --hard ORIG_HEAD" in case the end
result is really messy.
- Patch A applies cleanly. This could either be a clean patch
application on top of rewound head (i.e. same as upstream
head), or git-am might have internally fell back on 3-way
(i.e. it would have done the same thing as git-cherry-pick).
In either case, a rebased commit A is made on top of U.
- Patch C does not apply. git-am stops here, with conflicts to
be resolved in the working tree. Yet-to-be-applied D and E
are still kept in .dotest/ directory at this point. What the
user does is exactly the same as fixing up unapplicable patch
when running git-am:
- Resolve conflict just like any merge conflicts.
- "git am --resolved --3way" to continue applying the patches.
- This applies the fixed-up patch so by definition it had
better apply. "git am" knows the patch after the fixed-up
one is D and then E; it applies them, and you will get the
changes from A-C-D-E commits on top of U, in this order.
I've been using this without noticing any problem, and as people
may know I do a lot of rebases.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-14 08:41:53 +00:00
|
|
|
# If the branch to rebase is given, first switch to it.
|
2005-06-25 09:23:43 +00:00
|
|
|
case "$#" in
|
Rewrite rebase to use git-format-patch piped to git-am.
The current rebase implementation finds commits in our tree but
not in the upstream tree using git-cherry, and tries to apply
them using git-cherry-pick (i.e. always use 3-way) one by one.
Which is fine, but when some of the changes do not apply
cleanly, it punts, and punts badly.
Suppose you have commits A-B-C-D-E since you forked from the
upstream and submitted the changes for inclusion. You fetch
from upstream head U and find that B has been picked up. You
run git-rebase to update your branch, which tries to apply
changes contained in A-C-D-E, in this order, but replaying of C
fails, because the upstream got changes that touch the same area
from elsewhere.
Now what?
It notes that fact, and goes ahead to apply D and E, and at the
very end tells you to deal with C by hand. Even if you somehow
managed to replay C on top of the result, you would now end up
with ...-B-...-U-A-D-E-C.
Breaking the order between B and others was the conscious
decision made by the upstream, so we would not worry about it,
and even if it were worrisome, it is too late for us to fix now.
What D and E do may well depend on having C applied before them,
which is a problem for us.
This rewrites rebase to use git-format-patch piped to git-am,
and when the patch does not apply, have git-am fall back on
3-way merge. The updated diff/patch pair knows how to apply
trivial binary patches as long as the pre- and post-images are
locally available, so this should work on a repository with
binary files as well.
The primary benefit of this change is that it makes rebase
easier to use when some of the changes do not replay cleanly.
In the "unapplicable patch in the middle" case, this "rebase"
works like this:
- A series of patches in e-mail form is created that records
what A-C-D-E do, and is fed to git-am. This is stored in
.dotest/ directory, just like the case you tried to apply
them from your mailbox. Your branch is rewound to the tip of
upstream U, and the original head is kept in .git/ORIG_HEAD,
so you could "git reset --hard ORIG_HEAD" in case the end
result is really messy.
- Patch A applies cleanly. This could either be a clean patch
application on top of rewound head (i.e. same as upstream
head), or git-am might have internally fell back on 3-way
(i.e. it would have done the same thing as git-cherry-pick).
In either case, a rebased commit A is made on top of U.
- Patch C does not apply. git-am stops here, with conflicts to
be resolved in the working tree. Yet-to-be-applied D and E
are still kept in .dotest/ directory at this point. What the
user does is exactly the same as fixing up unapplicable patch
when running git-am:
- Resolve conflict just like any merge conflicts.
- "git am --resolved --3way" to continue applying the patches.
- This applies the fixed-up patch so by definition it had
better apply. "git am" knows the patch after the fixed-up
one is D and then E; it applies them, and you will get the
changes from A-C-D-E commits on top of U, in this order.
I've been using this without noticing any problem, and as people
may know I do a lot of rebases.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-14 08:41:53 +00:00
|
|
|
2)
|
2006-02-14 22:42:05 +00:00
|
|
|
branch_name="$2"
|
2005-12-13 22:30:32 +00:00
|
|
|
git-checkout "$2" || usage
|
2006-02-14 22:42:05 +00:00
|
|
|
;;
|
|
|
|
*)
|
2007-01-21 03:11:29 +00:00
|
|
|
if branch_name=`git symbolic-ref -q HEAD`
|
|
|
|
then
|
|
|
|
branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
|
|
|
|
else
|
|
|
|
branch_name=HEAD ;# detached
|
|
|
|
fi
|
2006-02-14 22:42:05 +00:00
|
|
|
;;
|
2005-06-25 09:23:43 +00:00
|
|
|
esac
|
2006-02-14 22:42:05 +00:00
|
|
|
branch=$(git-rev-parse --verify "${branch_name}^0") || exit
|
2005-06-25 09:23:43 +00:00
|
|
|
|
2006-02-14 22:42:05 +00:00
|
|
|
# Now we are rebasing commits $upstream..$branch on top of $onto
|
|
|
|
|
|
|
|
# Check if we are already based on $onto, but this should be
|
|
|
|
# done only when upstream and onto are the same.
|
2006-07-27 09:32:25 +00:00
|
|
|
mb=$(git-merge-base "$onto" "$branch")
|
|
|
|
if test "$upstream" = "$onto" && test "$mb" = "$onto"
|
2005-11-28 21:00:31 +00:00
|
|
|
then
|
2006-07-27 09:32:25 +00:00
|
|
|
echo >&2 "Current branch $branch_name is up to date."
|
|
|
|
exit 0
|
2005-11-28 21:00:31 +00:00
|
|
|
fi
|
|
|
|
|
2006-10-03 16:29:31 +00:00
|
|
|
if test -n "$verbose"
|
|
|
|
then
|
|
|
|
echo "Changes from $mb to $onto:"
|
|
|
|
git-diff-tree --stat --summary "$mb" "$onto"
|
|
|
|
fi
|
|
|
|
|
2006-02-14 22:42:05 +00:00
|
|
|
# Rewind the head to "$onto"; this saves our current head in ORIG_HEAD.
|
2006-12-22 23:21:55 +00:00
|
|
|
echo "First, rewinding head to replay your work on top of it..."
|
2006-02-14 22:42:05 +00:00
|
|
|
git-reset --hard "$onto"
|
2005-12-14 23:36:35 +00:00
|
|
|
|
2006-02-14 22:42:05 +00:00
|
|
|
# If the $onto is a proper descendant of the tip of the branch, then
|
2005-12-14 23:36:35 +00:00
|
|
|
# we just fast forwarded.
|
2006-07-27 09:32:25 +00:00
|
|
|
if test "$mb" = "$branch"
|
2005-12-14 23:36:35 +00:00
|
|
|
then
|
2006-07-27 09:32:46 +00:00
|
|
|
echo >&2 "Fast-forwarded $branch_name to $onto_name."
|
2005-12-14 23:36:35 +00:00
|
|
|
exit 0
|
|
|
|
fi
|
|
|
|
|
2006-06-21 10:04:41 +00:00
|
|
|
if test -z "$do_merge"
|
|
|
|
then
|
2006-10-03 16:29:26 +00:00
|
|
|
git-format-patch -k --stdout --full-index --ignore-if-in-upstream "$upstream"..ORIG_HEAD |
|
2007-02-08 13:57:08 +00:00
|
|
|
git am $git_am_opt --binary -3 -k --resolvemsg="$RESOLVEMSG"
|
2006-06-21 10:04:41 +00:00
|
|
|
exit $?
|
|
|
|
fi
|
|
|
|
|
|
|
|
# start doing a rebase with git-merge
|
|
|
|
# this is rename-aware if the recursive (default) strategy is used
|
|
|
|
|
|
|
|
mkdir -p "$dotest"
|
|
|
|
echo "$onto" > "$dotest/onto"
|
2006-12-28 07:34:56 +00:00
|
|
|
echo "$onto_name" > "$dotest/onto_name"
|
2006-06-21 10:04:41 +00:00
|
|
|
prev_head=`git-rev-parse HEAD^0`
|
|
|
|
echo "$prev_head" > "$dotest/prev_head"
|
|
|
|
|
|
|
|
msgnum=0
|
|
|
|
for cmt in `git-rev-list --no-merges "$upstream"..ORIG_HEAD \
|
2006-07-08 15:32:04 +00:00
|
|
|
| @@PERL@@ -e 'print reverse <>'`
|
2006-06-21 10:04:41 +00:00
|
|
|
do
|
|
|
|
msgnum=$(($msgnum + 1))
|
2006-06-22 08:44:54 +00:00
|
|
|
echo "$cmt" > "$dotest/cmt.$msgnum"
|
2006-06-21 10:04:41 +00:00
|
|
|
done
|
|
|
|
|
2006-06-22 08:44:54 +00:00
|
|
|
echo 1 >"$dotest/msgnum"
|
|
|
|
echo $msgnum >"$dotest/end"
|
2006-06-21 10:04:41 +00:00
|
|
|
|
|
|
|
end=$msgnum
|
|
|
|
msgnum=1
|
|
|
|
|
|
|
|
while test "$msgnum" -le "$end"
|
|
|
|
do
|
|
|
|
call_merge "$msgnum"
|
|
|
|
continue_merge
|
|
|
|
done
|
2006-05-14 03:34:08 +00:00
|
|
|
|
2006-06-21 10:04:41 +00:00
|
|
|
finish_rb_merge
|