2005-06-25 09:23:43 +00:00
|
|
|
#!/bin/sh
|
|
|
|
#
|
|
|
|
# Copyright (c) 2005 Junio C Hamano.
|
|
|
|
#
|
|
|
|
|
2010-05-31 22:51:32 +00:00
|
|
|
USAGE='[--interactive | -i] [-v] [--force-rebase | -f] [--no-ff] [--onto <newbase>] (<upstream>|--root) [<branch>] [--quiet | -q]'
|
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
|
2008-07-21 10:51:02 +00:00
|
|
|
original <branch> and remove the .git/rebase-apply 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
|
2008-03-10 14:38:33 +00:00
|
|
|
currently checked out branch is used.
|
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
|
2007-11-06 09:50:02 +00:00
|
|
|
OPTIONS_SPEC=
|
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
|
|
|
|
2009-11-20 11:02:44 +00:00
|
|
|
LF='
|
|
|
|
'
|
2011-02-06 18:43:37 +00:00
|
|
|
ok_to_skip_pre_rebase=
|
|
|
|
resolvemsg="
|
2006-05-14 03:34:08 +00:00
|
|
|
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\".
|
|
|
|
"
|
2011-02-06 18:43:37 +00:00
|
|
|
unset onto
|
2011-02-06 18:43:38 +00:00
|
|
|
strategy=
|
2010-07-28 22:04:29 +00:00
|
|
|
strategy_opts=
|
2006-06-21 10:04:41 +00:00
|
|
|
do_merge=
|
2011-02-06 18:43:30 +00:00
|
|
|
merge_dir="$GIT_DIR"/rebase-merge
|
|
|
|
apply_dir="$GIT_DIR"/rebase-apply
|
2006-06-21 10:04:41 +00:00
|
|
|
prec=4
|
2006-10-03 16:29:31 +00:00
|
|
|
verbose=
|
2010-11-09 20:59:00 +00:00
|
|
|
diffstat=
|
|
|
|
test "$(git config --bool rebase.stat)" = true && diffstat=t
|
2007-02-08 13:57:08 +00:00
|
|
|
git_am_opt=
|
2009-01-05 17:35:16 +00:00
|
|
|
rebase_root=
|
2009-02-13 22:48:01 +00:00
|
|
|
force_rebase=
|
2009-12-04 08:20:48 +00:00
|
|
|
allow_rerere_autoupdate=
|
2011-02-06 18:43:34 +00:00
|
|
|
# Non-empty if a rebase was in progress when 'git rebase' was invoked
|
|
|
|
in_progress=
|
|
|
|
# One of {am, merge, interactive}
|
|
|
|
type=
|
|
|
|
# One of {"$GIT_DIR"/rebase-apply, "$GIT_DIR"/rebase-merge}
|
|
|
|
state_dir=
|
2011-02-06 18:43:35 +00:00
|
|
|
# One of {'', continue, skip, abort}, as parsed from command line
|
|
|
|
action=
|
2011-02-06 18:43:39 +00:00
|
|
|
preserve_merges=
|
|
|
|
autosquash=
|
|
|
|
test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
|
2006-06-21 10:04:41 +00:00
|
|
|
|
rebase: refactor reading of state
The code reading the state saved in $merge_dir or $rebase_dir is
currently spread out in many places, making it harder to read and to
introduce additional state. Extract this code into one method that
reads the state. Only extract the code associated with the state that
is written when the rebase is initiated. Leave the state that changes
for each commmit, at least for now.
Currently, when resuming a merge-based rebase using --continue or
--skip, move_to_original_branch (via finish_rb_merge) will be called
without head_name and orig_head set. These variables are then lazily
read in move_to_original_branch if head_name is not set (together with
onto, which is unnecessarily read again). Change this by always
eagerly reading the state, for both am-based and merge-based rebase,
in the --continue and --skip cases. Note that this does not change the
behavior for am-based rebase, which read the state eagerly even before
this commit.
Reading the state eagerly means that part of the state will sometimes
be read unnecessarily. One example is when the rebase is continued,
but stops again at another merge conflict. Another example is when the
rebase is aborted. However, since both of these cases involve user
interaction, the delay is hopefully not noticeable. The
call_merge/continue_merge loop is not affected.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-02-06 18:43:31 +00:00
|
|
|
read_state () {
|
2011-02-06 18:43:34 +00:00
|
|
|
if test "$type" = merge
|
rebase: refactor reading of state
The code reading the state saved in $merge_dir or $rebase_dir is
currently spread out in many places, making it harder to read and to
introduce additional state. Extract this code into one method that
reads the state. Only extract the code associated with the state that
is written when the rebase is initiated. Leave the state that changes
for each commmit, at least for now.
Currently, when resuming a merge-based rebase using --continue or
--skip, move_to_original_branch (via finish_rb_merge) will be called
without head_name and orig_head set. These variables are then lazily
read in move_to_original_branch if head_name is not set (together with
onto, which is unnecessarily read again). Change this by always
eagerly reading the state, for both am-based and merge-based rebase,
in the --continue and --skip cases. Note that this does not change the
behavior for am-based rebase, which read the state eagerly even before
this commit.
Reading the state eagerly means that part of the state will sometimes
be read unnecessarily. One example is when the rebase is continued,
but stops again at another merge conflict. Another example is when the
rebase is aborted. However, since both of these cases involve user
interaction, the delay is hopefully not noticeable. The
call_merge/continue_merge loop is not affected.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-02-06 18:43:31 +00:00
|
|
|
then
|
2011-02-06 18:43:34 +00:00
|
|
|
onto_name=$(cat "$state_dir"/onto_name) &&
|
|
|
|
end=$(cat "$state_dir"/end) &&
|
|
|
|
msgnum=$(cat "$state_dir"/msgnum)
|
rebase: refactor reading of state
The code reading the state saved in $merge_dir or $rebase_dir is
currently spread out in many places, making it harder to read and to
introduce additional state. Extract this code into one method that
reads the state. Only extract the code associated with the state that
is written when the rebase is initiated. Leave the state that changes
for each commmit, at least for now.
Currently, when resuming a merge-based rebase using --continue or
--skip, move_to_original_branch (via finish_rb_merge) will be called
without head_name and orig_head set. These variables are then lazily
read in move_to_original_branch if head_name is not set (together with
onto, which is unnecessarily read again). Change this by always
eagerly reading the state, for both am-based and merge-based rebase,
in the --continue and --skip cases. Note that this does not change the
behavior for am-based rebase, which read the state eagerly even before
this commit.
Reading the state eagerly means that part of the state will sometimes
be read unnecessarily. One example is when the rebase is continued,
but stops again at another merge conflict. Another example is when the
rebase is aborted. However, since both of these cases involve user
interaction, the delay is hopefully not noticeable. The
call_merge/continue_merge loop is not affected.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-02-06 18:43:31 +00:00
|
|
|
fi &&
|
|
|
|
head_name=$(cat "$state_dir"/head-name) &&
|
|
|
|
onto=$(cat "$state_dir"/onto) &&
|
|
|
|
orig_head=$(cat "$state_dir"/orig-head) &&
|
|
|
|
GIT_QUIET=$(cat "$state_dir"/quiet)
|
|
|
|
}
|
|
|
|
|
2006-06-21 10:04:41 +00:00
|
|
|
continue_merge () {
|
2011-02-06 18:43:30 +00:00
|
|
|
test -d "$merge_dir" || die "$merge_dir directory does not exist"
|
2006-06-21 10:04:41 +00:00
|
|
|
|
2007-07-03 05:52:14 +00:00
|
|
|
unmerged=$(git ls-files -u)
|
2006-06-21 10:04:41 +00:00
|
|
|
if test -n "$unmerged"
|
|
|
|
then
|
|
|
|
echo "You still have unmerged paths in your index"
|
2007-06-02 17:59:49 +00:00
|
|
|
echo "did you forget to use git add?"
|
2011-02-06 18:43:37 +00:00
|
|
|
die "$resolvemsg"
|
2006-06-21 10:04:41 +00:00
|
|
|
fi
|
|
|
|
|
2011-02-06 18:43:30 +00:00
|
|
|
cmt=`cat "$merge_dir/current"`
|
2008-05-14 17:03:59 +00:00
|
|
|
if ! git diff-index --quiet --ignore-submodules HEAD --
|
2006-06-21 10:04:41 +00:00
|
|
|
then
|
2008-03-16 07:50:22 +00:00
|
|
|
if ! git commit --no-verify -C "$cmt"
|
2006-06-28 10:24:23 +00:00
|
|
|
then
|
|
|
|
echo "Commit failed, please do not call \"git commit\""
|
|
|
|
echo "directly, but instead do one of the following: "
|
2011-02-06 18:43:37 +00:00
|
|
|
die "$resolvemsg"
|
2006-06-28 10:24:23 +00:00
|
|
|
fi
|
2009-06-16 22:33:01 +00:00
|
|
|
if test -z "$GIT_QUIET"
|
|
|
|
then
|
|
|
|
printf "Committed: %0${prec}d " $msgnum
|
|
|
|
fi
|
2011-02-06 18:43:30 +00:00
|
|
|
echo "$cmt $(git rev-parse HEAD^0)" >> "$merge_dir/rewritten"
|
2006-06-21 10:04:41 +00:00
|
|
|
else
|
2009-06-16 22:33:01 +00:00
|
|
|
if test -z "$GIT_QUIET"
|
|
|
|
then
|
|
|
|
printf "Already applied: %0${prec}d " $msgnum
|
|
|
|
fi
|
|
|
|
fi
|
2010-01-25 07:06:31 +00:00
|
|
|
test -z "$GIT_QUIET" &&
|
2010-01-30 16:23:37 +00:00
|
|
|
GIT_PAGER='' git log --format=%s -1 "$cmt"
|
2006-06-21 10:04:41 +00:00
|
|
|
|
|
|
|
# onto the next patch:
|
|
|
|
msgnum=$(($msgnum + 1))
|
2011-02-06 18:43:30 +00:00
|
|
|
echo "$msgnum" >"$merge_dir/msgnum"
|
2006-06-21 10:04:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
call_merge () {
|
2011-02-06 18:43:30 +00:00
|
|
|
cmt="$(cat "$merge_dir/cmt.$1")"
|
|
|
|
echo "$cmt" > "$merge_dir/current"
|
2007-07-03 05:52:14 +00:00
|
|
|
hd=$(git rev-parse --verify HEAD)
|
2007-11-08 18:19:08 +00:00
|
|
|
cmt_name=$(git symbolic-ref HEAD 2> /dev/null || echo HEAD)
|
2011-02-06 18:43:30 +00:00
|
|
|
msgnum=$(cat "$merge_dir/msgnum")
|
2006-12-28 07:34:56 +00:00
|
|
|
eval GITHEAD_$cmt='"${cmt_name##refs/heads/}~$(($end - $msgnum))"'
|
2011-02-06 18:43:32 +00:00
|
|
|
eval GITHEAD_$hd='$onto_name'
|
2006-12-28 07:34:56 +00:00
|
|
|
export GITHEAD_$cmt GITHEAD_$hd
|
2009-06-16 22:33:01 +00:00
|
|
|
if test -n "$GIT_QUIET"
|
|
|
|
then
|
2010-10-13 18:36:36 +00:00
|
|
|
GIT_MERGE_VERBOSITY=1 && export GIT_MERGE_VERBOSITY
|
2009-06-16 22:33:01 +00:00
|
|
|
fi
|
2011-02-06 18:43:38 +00:00
|
|
|
test -z "$strategy" && strategy=recursive
|
2010-07-28 22:04:29 +00:00
|
|
|
eval 'git-merge-$strategy' $strategy_opts '"$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)
|
2009-12-04 08:20:48 +00:00
|
|
|
git rerere $allow_rerere_autoupdate
|
2011-02-06 18:43:37 +00:00
|
|
|
die "$resolvemsg"
|
2006-06-21 10:04:41 +00:00
|
|
|
;;
|
|
|
|
2)
|
|
|
|
echo "Strategy: $rv $strategy failed, try another" 1>&2
|
2011-02-06 18:43:37 +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
|
|
|
|
}
|
|
|
|
|
2007-11-08 18:19:08 +00:00
|
|
|
move_to_original_branch () {
|
|
|
|
case "$head_name" in
|
|
|
|
refs/*)
|
|
|
|
message="rebase finished: $head_name onto $onto"
|
|
|
|
git update-ref -m "$message" \
|
|
|
|
$head_name $(git rev-parse HEAD) $orig_head &&
|
|
|
|
git symbolic-ref HEAD $head_name ||
|
|
|
|
die "Could not move back to $head_name"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2006-06-21 10:04:41 +00:00
|
|
|
finish_rb_merge () {
|
2007-11-08 18:19:08 +00:00
|
|
|
move_to_original_branch
|
2011-02-06 18:43:30 +00:00
|
|
|
git notes copy --for-rewrite=rebase < "$merge_dir"/rewritten
|
2010-03-12 17:04:29 +00:00
|
|
|
if test -x "$GIT_DIR"/hooks/post-rewrite &&
|
2011-02-06 18:43:30 +00:00
|
|
|
test -s "$merge_dir"/rewritten; then
|
|
|
|
"$GIT_DIR"/hooks/post-rewrite rebase < "$merge_dir"/rewritten
|
2010-03-12 17:04:29 +00:00
|
|
|
fi
|
2011-02-06 18:43:30 +00:00
|
|
|
rm -r "$merge_dir"
|
2009-06-16 22:33:01 +00:00
|
|
|
say All done.
|
2006-06-21 10:04:41 +00:00
|
|
|
}
|
|
|
|
|
2011-02-06 18:43:39 +00:00
|
|
|
run_interactive_rebase () {
|
2008-09-29 20:28:57 +00:00
|
|
|
if [ "$interactive_rebase" = implied ]; then
|
|
|
|
GIT_EDITOR=:
|
|
|
|
export GIT_EDITOR
|
|
|
|
fi
|
2011-02-06 18:43:39 +00:00
|
|
|
. git-rebase--interactive "$@"
|
2007-06-25 00:11:14 +00:00
|
|
|
}
|
|
|
|
|
2008-10-06 05:14:24 +00:00
|
|
|
run_pre_rebase_hook () {
|
2011-02-06 18:43:37 +00:00
|
|
|
if test -z "$ok_to_skip_pre_rebase" &&
|
2008-10-06 05:14:29 +00:00
|
|
|
test -x "$GIT_DIR/hooks/pre-rebase"
|
2008-10-06 05:14:24 +00:00
|
|
|
then
|
2009-06-14 23:08:56 +00:00
|
|
|
"$GIT_DIR/hooks/pre-rebase" ${1+"$@"} ||
|
|
|
|
die "The pre-rebase hook refused to rebase."
|
2008-10-06 05:14:24 +00:00
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2011-02-06 18:43:30 +00:00
|
|
|
test -f "$apply_dir"/applying &&
|
2008-08-17 04:25:43 +00:00
|
|
|
die 'It looks like git-am is in progress. Cannot rebase.'
|
|
|
|
|
2011-02-06 18:43:34 +00:00
|
|
|
if test -d "$apply_dir"
|
|
|
|
then
|
|
|
|
type=am
|
|
|
|
state_dir="$apply_dir"
|
|
|
|
elif test -d "$merge_dir"
|
|
|
|
then
|
|
|
|
if test -f "$merge_dir"/interactive
|
|
|
|
then
|
|
|
|
type=interactive
|
|
|
|
interactive_rebase=explicit
|
|
|
|
else
|
|
|
|
type=merge
|
|
|
|
fi
|
|
|
|
state_dir="$merge_dir"
|
|
|
|
fi
|
|
|
|
test -n "$type" && in_progress=t
|
|
|
|
|
2011-02-06 18:43:36 +00:00
|
|
|
total_argc=$#
|
2007-09-23 20:42:08 +00:00
|
|
|
while test $# != 0
|
2006-02-14 22:42:05 +00:00
|
|
|
do
|
|
|
|
case "$1" in
|
2008-10-06 05:14:29 +00:00
|
|
|
--no-verify)
|
2011-02-06 18:43:37 +00:00
|
|
|
ok_to_skip_pre_rebase=yes
|
2008-10-06 05:14:29 +00:00
|
|
|
;;
|
2010-11-22 20:21:01 +00:00
|
|
|
--verify)
|
2011-02-06 18:43:37 +00:00
|
|
|
ok_to_skip_pre_rebase=
|
2010-11-22 20:21:01 +00:00
|
|
|
;;
|
2011-02-06 18:43:35 +00:00
|
|
|
--continue|--skip|--abort)
|
2011-02-06 18:43:36 +00:00
|
|
|
test $total_argc -eq 1 || usage
|
2011-02-06 18:43:35 +00:00
|
|
|
action=${1##--}
|
2006-04-26 14:49:38 +00:00
|
|
|
;;
|
2006-02-14 22:42:05 +00:00
|
|
|
--onto)
|
|
|
|
test 2 -le "$#" || usage
|
2011-02-06 18:43:37 +00:00
|
|
|
onto="$2"
|
2006-02-14 22:42:05 +00:00
|
|
|
shift
|
|
|
|
;;
|
2011-02-06 18:43:39 +00:00
|
|
|
-i|--interactive)
|
|
|
|
interactive_rebase=explicit
|
|
|
|
;;
|
|
|
|
-p|--preserve-merges)
|
|
|
|
preserve_merges=t
|
|
|
|
test -z "$interactive_rebase" && interactive_rebase=implied
|
|
|
|
;;
|
|
|
|
--autosquash)
|
|
|
|
autosquash=t
|
|
|
|
;;
|
|
|
|
--no-autosquash)
|
|
|
|
autosquash=
|
|
|
|
;;
|
2006-06-21 10:04:41 +00:00
|
|
|
-M|-m|--m|--me|--mer|--merg|--merge)
|
|
|
|
do_merge=t
|
|
|
|
;;
|
2010-07-28 22:04:29 +00:00
|
|
|
-X*|--strategy-option*)
|
|
|
|
case "$#,$1" in
|
|
|
|
1,-X|1,--strategy-option)
|
|
|
|
usage ;;
|
|
|
|
*,-X|*,--strategy-option)
|
|
|
|
newopt="$2"
|
|
|
|
shift ;;
|
|
|
|
*,--strategy-option=*)
|
|
|
|
newopt="$(expr " $1" : ' --strategy-option=\(.*\)')" ;;
|
|
|
|
*,-X*)
|
|
|
|
newopt="$(expr " $1" : ' -X\(.*\)')" ;;
|
|
|
|
1,*)
|
|
|
|
usage ;;
|
|
|
|
esac
|
|
|
|
strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--$newopt")"
|
|
|
|
do_merge=t
|
2011-02-06 18:43:38 +00:00
|
|
|
test -z "$strategy" && strategy=recursive
|
2010-07-28 22:04:29 +00:00
|
|
|
;;
|
2006-06-21 10:04:41 +00:00
|
|
|
-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
|
|
|
|
;;
|
2009-03-01 22:11:38 +00:00
|
|
|
-n|--no-stat)
|
|
|
|
diffstat=
|
|
|
|
;;
|
|
|
|
--stat)
|
|
|
|
diffstat=t
|
|
|
|
;;
|
2006-10-03 16:29:31 +00:00
|
|
|
-v|--verbose)
|
|
|
|
verbose=t
|
2009-03-01 22:11:38 +00:00
|
|
|
diffstat=t
|
2009-06-16 22:33:01 +00:00
|
|
|
GIT_QUIET=
|
|
|
|
;;
|
|
|
|
-q|--quiet)
|
|
|
|
GIT_QUIET=t
|
|
|
|
git_am_opt="$git_am_opt -q"
|
|
|
|
verbose=
|
|
|
|
diffstat=
|
2006-10-03 16:29:31 +00:00
|
|
|
;;
|
2007-09-07 14:20:50 +00:00
|
|
|
--whitespace=*)
|
|
|
|
git_am_opt="$git_am_opt $1"
|
2009-02-13 22:48:01 +00:00
|
|
|
case "$1" in
|
|
|
|
--whitespace=fix|--whitespace=strip)
|
|
|
|
force_rebase=t
|
|
|
|
;;
|
|
|
|
esac
|
2007-09-07 14:20:50 +00:00
|
|
|
;;
|
2009-08-04 11:16:49 +00:00
|
|
|
--ignore-whitespace)
|
|
|
|
git_am_opt="$git_am_opt $1"
|
|
|
|
;;
|
2009-03-18 20:53:49 +00:00
|
|
|
--committer-date-is-author-date|--ignore-date)
|
|
|
|
git_am_opt="$git_am_opt $1"
|
|
|
|
force_rebase=t
|
|
|
|
;;
|
2007-02-08 13:57:08 +00:00
|
|
|
-C*)
|
2007-09-07 14:20:50 +00:00
|
|
|
git_am_opt="$git_am_opt $1"
|
2007-02-08 13:57:08 +00:00
|
|
|
;;
|
2009-01-05 17:35:16 +00:00
|
|
|
--root)
|
|
|
|
rebase_root=t
|
|
|
|
;;
|
2010-08-08 05:13:32 +00:00
|
|
|
-f|--f|--fo|--for|--forc|--force|--force-r|--force-re|--force-reb|--force-reba|--force-rebas|--force-rebase|--no-ff)
|
2009-02-13 22:48:01 +00:00
|
|
|
force_rebase=t
|
|
|
|
;;
|
2009-12-04 08:20:48 +00:00
|
|
|
--rerere-autoupdate|--no-rerere-autoupdate)
|
|
|
|
allow_rerere_autoupdate="$1"
|
|
|
|
;;
|
2006-02-14 22:42:05 +00:00
|
|
|
-*)
|
|
|
|
usage
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
break
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
shift
|
|
|
|
done
|
2009-02-18 13:44:02 +00:00
|
|
|
test $# -gt 2 && usage
|
2005-12-14 11:11:37 +00:00
|
|
|
|
2011-02-06 18:43:39 +00:00
|
|
|
if test -n "$action"
|
|
|
|
then
|
|
|
|
test -z "$in_progress" && die "No rebase in progress?"
|
|
|
|
test "$type" = interactive && run_interactive_rebase
|
|
|
|
fi
|
2011-02-06 18:43:35 +00:00
|
|
|
|
|
|
|
case "$action" in
|
|
|
|
continue)
|
|
|
|
git update-index --ignore-submodules --refresh &&
|
|
|
|
git diff-files --quiet --ignore-submodules || {
|
|
|
|
echo "You must edit all merge conflicts and then"
|
|
|
|
echo "mark them as resolved using git add"
|
|
|
|
exit 1
|
|
|
|
}
|
|
|
|
read_state
|
|
|
|
if test -d "$merge_dir"
|
|
|
|
then
|
|
|
|
continue_merge
|
|
|
|
while test "$msgnum" -le "$end"
|
|
|
|
do
|
|
|
|
call_merge "$msgnum"
|
|
|
|
continue_merge
|
|
|
|
done
|
|
|
|
finish_rb_merge
|
|
|
|
exit
|
|
|
|
fi
|
2011-02-06 18:43:37 +00:00
|
|
|
git am --resolved --3way --resolvemsg="$resolvemsg" &&
|
2011-02-06 18:43:35 +00:00
|
|
|
move_to_original_branch
|
|
|
|
exit
|
|
|
|
;;
|
|
|
|
skip)
|
|
|
|
git reset --hard HEAD || exit $?
|
|
|
|
read_state
|
|
|
|
if test -d "$merge_dir"
|
|
|
|
then
|
|
|
|
git rerere clear
|
|
|
|
msgnum=$(($msgnum + 1))
|
|
|
|
while test "$msgnum" -le "$end"
|
|
|
|
do
|
|
|
|
call_merge "$msgnum"
|
|
|
|
continue_merge
|
|
|
|
done
|
|
|
|
finish_rb_merge
|
|
|
|
exit
|
|
|
|
fi
|
2011-02-06 18:43:37 +00:00
|
|
|
git am -3 --skip --resolvemsg="$resolvemsg" &&
|
2011-02-06 18:43:35 +00:00
|
|
|
move_to_original_branch
|
|
|
|
exit
|
|
|
|
;;
|
|
|
|
abort)
|
|
|
|
git rerere clear
|
|
|
|
read_state
|
|
|
|
case "$head_name" in
|
|
|
|
refs/*)
|
|
|
|
git symbolic-ref HEAD $head_name ||
|
|
|
|
die "Could not move back to $head_name"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
git reset --hard $orig_head
|
|
|
|
rm -r "$state_dir"
|
|
|
|
exit
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
2011-02-06 18:43:34 +00:00
|
|
|
# Make sure no rebase is in progress
|
|
|
|
if test -n "$in_progress"
|
2005-11-28 21:00:31 +00:00
|
|
|
then
|
2011-02-06 18:43:34 +00:00
|
|
|
die '
|
|
|
|
It seems that there is already a '"${state_dir##*/}"' directory, and
|
|
|
|
I wonder if you are in the middle of another rebase. If that is the
|
|
|
|
case, please try
|
|
|
|
git rebase (--continue | --abort | --skip)
|
|
|
|
If that is not the case, please
|
|
|
|
rm -fr '"$state_dir"'
|
2008-08-17 04:25:43 +00:00
|
|
|
and run me again. I am stopping in case you still have something
|
2008-07-21 10:51:02 +00:00
|
|
|
valuable there.'
|
2005-11-28 21:00:31 +00:00
|
|
|
fi
|
|
|
|
|
2011-02-06 18:43:34 +00:00
|
|
|
test $# -eq 0 && test -z "$rebase_root" && usage
|
|
|
|
|
2011-02-06 18:43:39 +00:00
|
|
|
if test -n "$interactive_rebase"
|
|
|
|
then
|
|
|
|
type=interactive
|
|
|
|
state_dir="$merge_dir"
|
|
|
|
elif test -n "$do_merge"
|
|
|
|
then
|
|
|
|
type=merge
|
|
|
|
state_dir="$merge_dir"
|
|
|
|
else
|
|
|
|
type=am
|
|
|
|
state_dir="$apply_dir"
|
|
|
|
fi
|
|
|
|
|
2009-01-05 17:35:16 +00:00
|
|
|
if test -z "$rebase_root"
|
|
|
|
then
|
|
|
|
# The upstream head must be given. Make sure it is valid.
|
|
|
|
upstream_name="$1"
|
|
|
|
shift
|
|
|
|
upstream=`git rev-parse --verify "${upstream_name}^0"` ||
|
|
|
|
die "invalid upstream $upstream_name"
|
|
|
|
unset root_flag
|
|
|
|
upstream_arg="$upstream_name"
|
|
|
|
else
|
2011-02-06 18:43:42 +00:00
|
|
|
test -z "$onto" && die "You must specify --onto when using --root"
|
2009-01-05 17:35:16 +00:00
|
|
|
unset upstream_name
|
|
|
|
unset upstream
|
|
|
|
root_flag="--root"
|
|
|
|
upstream_arg="$root_flag"
|
|
|
|
fi
|
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.
|
2011-02-06 18:43:37 +00:00
|
|
|
onto_name=${onto-"$upstream_name"}
|
2010-01-07 11:05:02 +00:00
|
|
|
case "$onto_name" in
|
|
|
|
*...*)
|
|
|
|
if left=${onto_name%...*} right=${onto_name#*...} &&
|
|
|
|
onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
|
|
|
|
then
|
|
|
|
case "$onto" in
|
|
|
|
?*"$LF"?*)
|
|
|
|
die "$onto_name: there are more than one merge bases"
|
|
|
|
;;
|
|
|
|
'')
|
|
|
|
die "$onto_name: there is no merge base"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
else
|
2009-11-20 11:02:44 +00:00
|
|
|
die "$onto_name: there is no merge base"
|
2010-01-07 11:05:02 +00:00
|
|
|
fi
|
|
|
|
;;
|
|
|
|
*)
|
2011-02-06 18:43:42 +00:00
|
|
|
onto=$(git rev-parse --verify "${onto_name}^0") ||
|
|
|
|
die "Does not point to a valid commit: $1"
|
2010-01-07 11:05:02 +00:00
|
|
|
;;
|
|
|
|
esac
|
2007-03-22 09:54:59 +00:00
|
|
|
|
2008-03-15 20:17:42 +00:00
|
|
|
# If the branch to rebase is given, that is the branch we will rebase
|
|
|
|
# $branch_name -- branch being rebased, or HEAD (already detached)
|
|
|
|
# $orig_head -- commit object name of tip of the branch before rebasing
|
|
|
|
# $head_name -- refs/heads/<that-branch> or "detached HEAD"
|
|
|
|
switch_to=
|
2005-06-25 09:23:43 +00:00
|
|
|
case "$#" in
|
2009-01-05 17:35:16 +00:00
|
|
|
1)
|
2008-03-15 20:17:42 +00:00
|
|
|
# Is it "rebase other $branchname" or "rebase other $commit"?
|
2009-01-05 17:35:16 +00:00
|
|
|
branch_name="$1"
|
|
|
|
switch_to="$1"
|
2008-03-15 20:17:42 +00:00
|
|
|
|
2009-01-05 17:35:16 +00:00
|
|
|
if git show-ref --verify --quiet -- "refs/heads/$1" &&
|
|
|
|
branch=$(git rev-parse -q --verify "refs/heads/$1")
|
2008-03-15 20:17:42 +00:00
|
|
|
then
|
2009-01-05 17:35:16 +00:00
|
|
|
head_name="refs/heads/$1"
|
|
|
|
elif branch=$(git rev-parse -q --verify "$1")
|
2008-03-15 20:17:42 +00:00
|
|
|
then
|
|
|
|
head_name="detached HEAD"
|
|
|
|
else
|
2011-01-27 00:27:11 +00:00
|
|
|
echo >&2 "fatal: no such branch: $1"
|
2008-03-15 20:17:42 +00:00
|
|
|
usage
|
|
|
|
fi
|
2006-02-14 22:42:05 +00:00
|
|
|
;;
|
|
|
|
*)
|
2008-03-15 20:17:42 +00:00
|
|
|
# Do not need to switch branches, we are already on it.
|
2007-01-21 03:11:29 +00:00
|
|
|
if branch_name=`git symbolic-ref -q HEAD`
|
|
|
|
then
|
2008-03-15 20:17:42 +00:00
|
|
|
head_name=$branch_name
|
2007-01-21 03:11:29 +00:00
|
|
|
branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
|
|
|
|
else
|
2008-03-15 20:17:42 +00:00
|
|
|
head_name="detached HEAD"
|
2007-01-21 03:11:29 +00:00
|
|
|
branch_name=HEAD ;# detached
|
|
|
|
fi
|
2008-03-15 20:17:42 +00:00
|
|
|
branch=$(git rev-parse --verify "${branch_name}^0") || exit
|
2006-02-14 22:42:05 +00:00
|
|
|
;;
|
2005-06-25 09:23:43 +00:00
|
|
|
esac
|
2008-03-15 20:17:42 +00:00
|
|
|
orig_head=$branch
|
2005-06-25 09:23:43 +00:00
|
|
|
|
2011-02-06 18:43:41 +00:00
|
|
|
require_clean_work_tree "rebase" "Please commit or stash them."
|
|
|
|
|
2011-02-06 18:43:43 +00:00
|
|
|
test "$type" = interactive && run_interactive_rebase "$@"
|
|
|
|
|
2009-01-05 17:35:16 +00:00
|
|
|
# Now we are rebasing commits $upstream..$branch (or with --root,
|
|
|
|
# everything leading up to $branch) on top of $onto
|
2006-02-14 22:42:05 +00:00
|
|
|
|
2007-07-04 20:09:10 +00:00
|
|
|
# Check if we are already based on $onto with linear history,
|
|
|
|
# but this should be done only when upstream and onto are the same.
|
2007-07-03 05:52:14 +00:00
|
|
|
mb=$(git merge-base "$onto" "$branch")
|
2007-07-04 20:09:10 +00:00
|
|
|
if test "$upstream" = "$onto" && test "$mb" = "$onto" &&
|
|
|
|
# linear history?
|
2009-11-23 23:56:32 +00:00
|
|
|
! (git rev-list --parents "$onto".."$branch" | sane_grep " .* ") > /dev/null
|
2005-11-28 21:00:31 +00:00
|
|
|
then
|
2009-02-13 22:48:01 +00:00
|
|
|
if test -z "$force_rebase"
|
|
|
|
then
|
|
|
|
# Lazily switch to the target branch if needed...
|
2011-01-27 00:26:59 +00:00
|
|
|
test -z "$switch_to" || git checkout "$switch_to" --
|
2009-06-16 22:33:01 +00:00
|
|
|
say "Current branch $branch_name is up to date."
|
2009-02-13 22:48:01 +00:00
|
|
|
exit 0
|
|
|
|
else
|
2009-06-16 22:33:01 +00:00
|
|
|
say "Current branch $branch_name is up to date, rebase forced."
|
2009-02-13 22:48:01 +00:00
|
|
|
fi
|
2005-11-28 21:00:31 +00:00
|
|
|
fi
|
|
|
|
|
2011-02-06 18:43:41 +00:00
|
|
|
# If a hook exists, give it a chance to interrupt
|
|
|
|
run_pre_rebase_hook "$upstream_arg" "$@"
|
|
|
|
|
2008-03-15 20:17:42 +00:00
|
|
|
# Detach HEAD and reset the tree
|
2009-06-16 22:33:01 +00:00
|
|
|
say "First, rewinding head to replay your work on top of it..."
|
2008-07-14 21:05:35 +00:00
|
|
|
git checkout -q "$onto^0" || die "could not detach HEAD"
|
2008-07-07 07:16:38 +00:00
|
|
|
git update-ref ORIG_HEAD $branch
|
2005-12-14 23:36:35 +00:00
|
|
|
|
2009-03-01 22:11:38 +00:00
|
|
|
if test -n "$diffstat"
|
|
|
|
then
|
|
|
|
if test -n "$verbose"
|
|
|
|
then
|
|
|
|
echo "Changes from $mb to $onto:"
|
|
|
|
fi
|
|
|
|
# We want color (if set), but no pager
|
|
|
|
GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
|
|
|
|
fi
|
|
|
|
|
2006-02-14 22:42:05 +00:00
|
|
|
# If the $onto is a proper descendant of the tip of the branch, then
|
2009-10-24 08:31:32 +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
|
2009-06-16 22:33:01 +00:00
|
|
|
say "Fast-forwarded $branch_name to $onto_name."
|
2007-11-08 18:19:08 +00:00
|
|
|
move_to_original_branch
|
2005-12-14 23:36:35 +00:00
|
|
|
exit 0
|
|
|
|
fi
|
|
|
|
|
2009-01-05 17:35:16 +00:00
|
|
|
if test -n "$rebase_root"
|
|
|
|
then
|
|
|
|
revisions="$onto..$orig_head"
|
|
|
|
else
|
|
|
|
revisions="$upstream..$orig_head"
|
|
|
|
fi
|
|
|
|
|
2006-06-21 10:04:41 +00:00
|
|
|
if test -z "$do_merge"
|
|
|
|
then
|
2008-03-15 20:17:42 +00:00
|
|
|
git format-patch -k --stdout --full-index --ignore-if-in-upstream \
|
2010-09-09 18:49:51 +00:00
|
|
|
--src-prefix=a/ --dst-prefix=b/ \
|
2008-11-11 00:15:49 +00:00
|
|
|
--no-renames $root_flag "$revisions" |
|
2011-02-06 18:43:37 +00:00
|
|
|
git am $git_am_opt --rebasing --resolvemsg="$resolvemsg" &&
|
2007-11-08 18:19:08 +00:00
|
|
|
move_to_original_branch
|
|
|
|
ret=$?
|
2011-02-06 18:43:30 +00:00
|
|
|
test 0 != $ret -a -d "$apply_dir" &&
|
|
|
|
echo $head_name > "$apply_dir/head-name" &&
|
|
|
|
echo $onto > "$apply_dir/onto" &&
|
|
|
|
echo $orig_head > "$apply_dir/orig-head" &&
|
|
|
|
echo "$GIT_QUIET" > "$apply_dir/quiet"
|
2007-11-08 18:19:08 +00:00
|
|
|
exit $ret
|
2006-06-21 10:04:41 +00:00
|
|
|
fi
|
|
|
|
|
|
|
|
# start doing a rebase with git-merge
|
|
|
|
# this is rename-aware if the recursive (default) strategy is used
|
|
|
|
|
2011-02-06 18:43:30 +00:00
|
|
|
mkdir -p "$merge_dir"
|
|
|
|
echo "$onto_name" > "$merge_dir/onto_name"
|
|
|
|
echo "$head_name" > "$merge_dir/head-name"
|
rebase: refactor reading of state
The code reading the state saved in $merge_dir or $rebase_dir is
currently spread out in many places, making it harder to read and to
introduce additional state. Extract this code into one method that
reads the state. Only extract the code associated with the state that
is written when the rebase is initiated. Leave the state that changes
for each commmit, at least for now.
Currently, when resuming a merge-based rebase using --continue or
--skip, move_to_original_branch (via finish_rb_merge) will be called
without head_name and orig_head set. These variables are then lazily
read in move_to_original_branch if head_name is not set (together with
onto, which is unnecessarily read again). Change this by always
eagerly reading the state, for both am-based and merge-based rebase,
in the --continue and --skip cases. Note that this does not change the
behavior for am-based rebase, which read the state eagerly even before
this commit.
Reading the state eagerly means that part of the state will sometimes
be read unnecessarily. One example is when the rebase is continued,
but stops again at another merge conflict. Another example is when the
rebase is aborted. However, since both of these cases involve user
interaction, the delay is hopefully not noticeable. The
call_merge/continue_merge loop is not affected.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-02-06 18:43:31 +00:00
|
|
|
echo "$onto" > "$merge_dir/onto"
|
|
|
|
echo "$orig_head" > "$merge_dir/orig-head"
|
2011-02-06 18:43:30 +00:00
|
|
|
echo "$GIT_QUIET" > "$merge_dir/quiet"
|
2006-06-21 10:04:41 +00:00
|
|
|
|
|
|
|
msgnum=0
|
2009-01-05 17:35:16 +00:00
|
|
|
for cmt in `git rev-list --reverse --no-merges "$revisions"`
|
2006-06-21 10:04:41 +00:00
|
|
|
do
|
|
|
|
msgnum=$(($msgnum + 1))
|
2011-02-06 18:43:30 +00:00
|
|
|
echo "$cmt" > "$merge_dir/cmt.$msgnum"
|
2006-06-21 10:04:41 +00:00
|
|
|
done
|
|
|
|
|
2011-02-06 18:43:30 +00:00
|
|
|
echo 1 >"$merge_dir/msgnum"
|
|
|
|
echo $msgnum >"$merge_dir/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
|