undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rebase: align variable names

Browse Source 
git-rebase--interactive.sh will soon be sourced from
git-rebase.sh. Align the names of variables used in these scripts to
prepare for that.

Some names in git-rebase--interactive.sh, such as "author_script" and
"amend", are currently used in their upper case form to refer to a
file and in their lower case form to refer to something else. In these
cases, change the name of the existing lower case variable and
downcase the name of the variable that refers to the file.

Currently, git-rebase.sh uses mostly lower case variable names, while
git-rebase--interactive.sh uses mostly upper case variable names. For
consistency, downcase all variables, not just the ones that will be
shared between the two script files.

Helped-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Martin von Zweigbergk 2011-02-06 13:43:37 -05:00 committed by Junio C Hamano
parent 95135b06fe
commit 6bb4e485cf
2 changed files with 255 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

478
git-rebase--interactive.sh
View File

@ -36,22 +36,22 @@ autosquash move commits that begin with squash!/fixup! under -i
. git-sh-setup . git-sh-setup
require_work_tree require_work_tree
DOTEST="$GIT_DIR/rebase-merge" dotest="$GIT_DIR/rebase-merge"
# The file containing rebase commands, comments, and empty lines. # The file containing rebase commands, comments, and empty lines.
# This file is created by "git rebase -i" then edited by the user. As # This file is created by "git rebase -i" then edited by the user. As
# the lines are processed, they are removed from the front of this # the lines are processed, they are removed from the front of this
# file and written to the tail of $DONE. # file and written to the tail of $done.
TODO="$DOTEST"/git-rebase-todo todo="$dotest"/git-rebase-todo
# The rebase command lines that have already been processed. A line # The rebase command lines that have already been processed. A line
# is moved here when it is first handled, before any associated user # is moved here when it is first handled, before any associated user
# actions. # actions.
DONE="$DOTEST"/done done="$dotest"/done
# The commit message that is planned to be used for any changes that # The commit message that is planned to be used for any changes that
# need to be committed following a user interaction. # need to be committed following a user interaction.
MSG="$DOTEST"/message msg="$dotest"/message
# The file into which is accumulated the suggested commit message for # The file into which is accumulated the suggested commit message for
# squash/fixup commands. When the first of a series of squash/fixups # squash/fixup commands. When the first of a series of squash/fixups
@ -61,34 +61,34 @@ MSG="$DOTEST"/message
# is appended to the file as it is processed. # is appended to the file as it is processed.
# #
# The first line of the file is of the form # The first line of the file is of the form
# # This is a combination of $COUNT commits. # # This is a combination of $count commits.
# where $COUNT is the number of commits whose messages have been # where $count is the number of commits whose messages have been
# written to the file so far (including the initial "pick" commit). # written to the file so far (including the initial "pick" commit).
# Each time that a commit message is processed, this line is read and # Each time that a commit message is processed, this line is read and
# updated. It is deleted just before the combined commit is made. # updated. It is deleted just before the combined commit is made.
SQUASH_MSG="$DOTEST"/message-squash squash_msg="$dotest"/message-squash
# If the current series of squash/fixups has not yet included a squash # If the current series of squash/fixups has not yet included a squash
# command, then this file exists and holds the commit message of the # command, then this file exists and holds the commit message of the
# original "pick" commit. (If the series ends without a "squash" # original "pick" commit. (If the series ends without a "squash"
# command, then this can be used as the commit message of the combined # command, then this can be used as the commit message of the combined
# commit without opening the editor.) # commit without opening the editor.)
FIXUP_MSG="$DOTEST"/message-fixup fixup_msg="$dotest"/message-fixup
# $REWRITTEN is the name of a directory containing files for each # $rewritten is the name of a directory containing files for each
# commit that is reachable by at least one merge base of $HEAD and # commit that is reachable by at least one merge base of $head and
# $UPSTREAM. They are not necessarily rewritten, but their children # $upstream. They are not necessarily rewritten, but their children
# might be. This ensures that commits on merged, but otherwise # might be. This ensures that commits on merged, but otherwise
# unrelated side branches are left alone. (Think "X" in the man page's # unrelated side branches are left alone. (Think "X" in the man page's
# example.) # example.)
REWRITTEN="$DOTEST"/rewritten rewritten="$dotest"/rewritten
DROPPED="$DOTEST"/dropped dropped="$dotest"/dropped
# A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and # 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 # GIT_AUTHOR_DATE that will be used for the commit that is currently
# being rebased. # being rebased.
AUTHOR_SCRIPT="$DOTEST"/author-script author_script="$dotest"/author-script
# When an "edit" rebase command is being processed, the SHA1 of the # When an "edit" rebase command is being processed, the SHA1 of the
# commit to be edited is recorded in this file. When "git rebase # commit to be edited is recorded in this file. When "git rebase
@ -96,24 +96,24 @@ AUTHOR_SCRIPT="$DOTEST"/author-script
# will be amended to the HEAD commit, but only provided the HEAD # will be amended to the HEAD commit, but only provided the HEAD
# commit is still the commit to be edited. When any other rebase # commit is still the commit to be edited. When any other rebase
# command is processed, this file is deleted. # command is processed, this file is deleted.
AMEND="$DOTEST"/amend amend="$dotest"/amend
# For the post-rewrite hook, we make a list of rewritten commits and # For the post-rewrite hook, we make a list of rewritten commits and
# their new sha1s. The rewritten-pending list keeps the sha1s of # their new sha1s. The rewritten-pending list keeps the sha1s of
# commits that have been processed, but not committed yet, # commits that have been processed, but not committed yet,
# e.g. because they are waiting for a 'squash' command. # e.g. because they are waiting for a 'squash' command.
REWRITTEN_LIST="$DOTEST"/rewritten-list rewritten_list="$dotest"/rewritten-list
REWRITTEN_PENDING="$DOTEST"/rewritten-pending rewritten_pending="$dotest"/rewritten-pending
PRESERVE_MERGES= preserve_merges=
STRATEGY= strategy=
ONTO= onto=
VERBOSE= verbose=
OK_TO_SKIP_PRE_REBASE= ok_to_skip_pre_rebase=
REBASE_ROOT= rebase_root=
AUTOSQUASH= autosquash=
test "$(git config --bool rebase.autosquash)" = "true" && AUTOSQUASH=t test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
NEVER_FF= force_rebase=
GIT_CHERRY_PICK_HELP="\ GIT_CHERRY_PICK_HELP="\
hint: after resolving the conflicts, mark the corrected paths hint: after resolving the conflicts, mark the corrected paths
@ -125,7 +125,7 @@ warn () {
} }
output () { output () {
case "$VERBOSE" in case "$verbose" in
'') '')
output=$("$@" 2>&1 ) output=$("$@" 2>&1 )
status=$? status=$?
@ -144,7 +144,7 @@ commit_message () {
} }
run_pre_rebase_hook () { run_pre_rebase_hook () {
if test -z "$OK_TO_SKIP_PRE_REBASE" && if test -z "$ok_to_skip_pre_rebase" &&
test -x "$GIT_DIR/hooks/pre-rebase" test -x "$GIT_DIR/hooks/pre-rebase"
then then
"$GIT_DIR/hooks/pre-rebase" ${1+"$@"} || { "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} || {
@ -155,10 +155,10 @@ run_pre_rebase_hook () {
} }
ORIG_REFLOG_ACTION="$GIT_REFLOG_ACTION" orig_reflog_action="$GIT_REFLOG_ACTION"
comment_for_reflog () { comment_for_reflog () {
case "$ORIG_REFLOG_ACTION" in case "$orig_reflog_action" in
''|rebase*) ''|rebase*)
GIT_REFLOG_ACTION="rebase -i ($1)" GIT_REFLOG_ACTION="rebase -i ($1)"
export GIT_REFLOG_ACTION export GIT_REFLOG_ACTION
@ -168,16 +168,16 @@ comment_for_reflog () {
last_count= last_count=
mark_action_done () { mark_action_done () {
sed -e 1q < "$TODO" >> "$DONE" sed -e 1q < "$todo" >> "$done"
sed -e 1d < "$TODO" >> "$TODO".new sed -e 1d < "$todo" >> "$todo".new
mv -f "$TODO".new "$TODO" mv -f "$todo".new "$todo"
count=$(sane_grep -c '^[^#]' < "$DONE") new_count=$(sane_grep -c '^[^#]' < "$done")
total=$(($count+$(sane_grep -c '^[^#]' < "$TODO"))) total=$(($new_count+$(sane_grep -c '^[^#]' < "$todo")))
if test "$last_count" != "$count" if test "$last_count" != "$new_count"
then then
last_count=$count last_count=$new_count
printf "Rebasing (%d/%d)\r" $count $total printf "Rebasing (%d/%d)\r" $new_count $total
test -z "$VERBOSE" || echo test -z "$verbose" || echo
fi fi
} }
@ -193,22 +193,22 @@ make_patch () {
*) *)
echo "Root commit" echo "Root commit"
;; ;;
esac > "$DOTEST"/patch esac > "$dotest"/patch
test -f "$MSG" || test -f "$msg" ||
commit_message "$1" > "$MSG" commit_message "$1" > "$msg"
test -f "$AUTHOR_SCRIPT" || test -f "$author_script" ||
get_author_ident_from_commit "$1" > "$AUTHOR_SCRIPT" get_author_ident_from_commit "$1" > "$author_script"
} }
die_with_patch () { die_with_patch () {
echo "$1" > "$DOTEST"/stopped-sha echo "$1" > "$dotest"/stopped-sha
make_patch "$1" make_patch "$1"
git rerere git rerere
die "$2" die "$2"
} }
die_abort () { die_abort () {
rm -rf "$DOTEST" rm -rf "$dotest"
die "$1" die "$1"
} }
@ -228,11 +228,11 @@ do_with_author () {
pick_one () { pick_one () {
ff=--ff ff=--ff
case "$1" in -n) sha1=$2; ff= ;; *) sha1=$1 ;; esac case "$1" in -n) sha1=$2; ff= ;; *) sha1=$1 ;; esac
case "$NEVER_FF" in '') ;; ?*) ff= ;; esac case "$force_rebase" in '') ;; ?*) ff= ;; esac
output git rev-parse --verify $sha1 || die "Invalid commit name: $sha1" output git rev-parse --verify $sha1 || die "Invalid commit name: $sha1"
test -d "$REWRITTEN" && test -d "$rewritten" &&
pick_one_preserving_merges "$@" && return pick_one_preserving_merges "$@" && return
if test -n "$REBASE_ROOT" if test -n "$rebase_root"
then then
output git cherry-pick "$@" output git cherry-pick "$@"
return return
@ -253,20 +253,20 @@ pick_one_preserving_merges () {
esac esac
sha1=$(git rev-parse $sha1) sha1=$(git rev-parse $sha1)
if test -f "$DOTEST"/current-commit if test -f "$dotest"/current-commit
then then
if test "$fast_forward" = t if test "$fast_forward" = t
then then
while read current_commit while read current_commit
do do
git rev-parse HEAD > "$REWRITTEN"/$current_commit git rev-parse HEAD > "$rewritten"/$current_commit
done <"$DOTEST"/current-commit done <"$dotest"/current-commit
rm "$DOTEST"/current-commit || rm "$dotest"/current-commit ||
die "Cannot write current commit's replacement sha1" die "Cannot write current commit's replacement sha1"
fi fi
fi fi
echo $sha1 >> "$DOTEST"/current-commit echo $sha1 >> "$dotest"/current-commit
# rewrite parents; if none were rewritten, we can fast-forward. # rewrite parents; if none were rewritten, we can fast-forward.
new_parents= new_parents=
@ -280,9 +280,9 @@ pick_one_preserving_merges () {
p=$(expr "$pend" : ' \([^ ]*\)') p=$(expr "$pend" : ' \([^ ]*\)')
pend="${pend# $p}" pend="${pend# $p}"
if test -f "$REWRITTEN"/$p if test -f "$rewritten"/$p
then then
new_p=$(cat "$REWRITTEN"/$p) new_p=$(cat "$rewritten"/$p)
# If the todo reordered commits, and our parent is marked for # If the todo reordered commits, and our parent is marked for
# rewriting, but hasn't been gotten to yet, assume the user meant to # rewriting, but hasn't been gotten to yet, assume the user meant to
@ -301,10 +301,10 @@ pick_one_preserving_merges () {
;; ;;
esac esac
else else
if test -f "$DROPPED"/$p if test -f "$dropped"/$p
then then
fast_forward=f fast_forward=f
replacement="$(cat "$DROPPED"/$p)" replacement="$(cat "$dropped"/$p)"
test -z "$replacement" && replacement=root test -z "$replacement" && replacement=root
pend=" $replacement$pend" pend=" $replacement$pend"
else else
@ -333,18 +333,18 @@ pick_one_preserving_merges () {
test "a$1" = a-n && die "Refusing to squash a merge: $sha1" test "a$1" = a-n && die "Refusing to squash a merge: $sha1"
# redo merge # redo merge
author_script=$(get_author_ident_from_commit $sha1) author_script_content=$(get_author_ident_from_commit $sha1)
eval "$author_script" eval "$author_script_content"
msg="$(commit_message $sha1)" msg_content="$(commit_message $sha1)"
# No point in merging the first parent, that's HEAD # No point in merging the first parent, that's HEAD
new_parents=${new_parents# $first_parent} new_parents=${new_parents# $first_parent}
if ! do_with_author output \ if ! do_with_author output \
git merge $STRATEGY -m "$msg" $new_parents git merge $strategy -m "$msg_content" $new_parents
then then
printf "%s\n" "$msg" > "$GIT_DIR"/MERGE_MSG printf "%s\n" "$msg_content" > "$GIT_DIR"/MERGE_MSG
die_with_patch $sha1 "Error redoing merge $sha1" die_with_patch $sha1 "Error redoing merge $sha1"
fi fi
echo "$sha1 $(git rev-parse HEAD^0)" >> "$REWRITTEN_LIST" echo "$sha1 $(git rev-parse HEAD^0)" >> "$rewritten_list"
;; ;;
*) *)
output git cherry-pick "$@" || output git cherry-pick "$@" ||
@ -365,46 +365,46 @@ nth_string () {
} }
update_squash_messages () { update_squash_messages () {
if test -f "$SQUASH_MSG"; then if test -f "$squash_msg"; then
mv "$SQUASH_MSG" "$SQUASH_MSG".bak || exit mv "$squash_msg" "$squash_msg".bak || exit
COUNT=$(($(sed -n \ count=$(($(sed -n \
-e "1s/^# This is a combination of \(.*\) commits\./\1/p" \ -e "1s/^# This is a combination of \(.*\) commits\./\1/p" \
-e "q" < "$SQUASH_MSG".bak)+1)) -e "q" < "$squash_msg".bak)+1))
{ {
echo "# This is a combination of $COUNT commits." echo "# This is a combination of $count commits."
sed -e 1d -e '2,/^./{ sed -e 1d -e '2,/^./{
/^$/d /^$/d
}' <"$SQUASH_MSG".bak }' <"$squash_msg".bak
} >"$SQUASH_MSG" } >"$squash_msg"
else else
commit_message HEAD > "$FIXUP_MSG" || die "Cannot write $FIXUP_MSG" commit_message HEAD > "$fixup_msg" || die "Cannot write $fixup_msg"
COUNT=2 count=2
{ {
echo "# This is a combination of 2 commits." echo "# This is a combination of 2 commits."
echo "# The first commit's message is:" echo "# The first commit's message is:"
echo echo
cat "$FIXUP_MSG" cat "$fixup_msg"
} >"$SQUASH_MSG" } >"$squash_msg"
fi fi
case $1 in case $1 in
squash) squash)
rm -f "$FIXUP_MSG" rm -f "$fixup_msg"
echo echo
echo "# This is the $(nth_string $COUNT) commit message:" echo "# This is the $(nth_string $count) commit message:"
echo echo
commit_message $2 commit_message $2
;; ;;
fixup) fixup)
echo echo
echo "# The $(nth_string $COUNT) commit message will be skipped:" echo "# The $(nth_string $count) commit message will be skipped:"
echo echo
commit_message $2 | sed -e 's/^/# /' commit_message $2 | sed -e 's/^/# /'
;; ;;
esac >>"$SQUASH_MSG" esac >>"$squash_msg"
} }
peek_next_command () { peek_next_command () {
sed -n -e "/^#/d" -e '/^$/d' -e "s/ .*//p" -e "q" < "$TODO" sed -n -e "/^#/d" -e '/^$/d' -e "s/ .*//p" -e "q" < "$todo"
} }
# A squash/fixup has failed. Prepare the long version of the squash # A squash/fixup has failed. Prepare the long version of the squash
@ -414,24 +414,24 @@ peek_next_command () {
# messages, effectively causing the combined commit to be used as the # messages, effectively causing the combined commit to be used as the
# new basis for any further squash/fixups. Args: sha1 rest # new basis for any further squash/fixups. Args: sha1 rest
die_failed_squash() { die_failed_squash() {
mv "$SQUASH_MSG" "$MSG" || exit mv "$squash_msg" "$msg" || exit
rm -f "$FIXUP_MSG" rm -f "$fixup_msg"
cp "$MSG" "$GIT_DIR"/MERGE_MSG || exit cp "$msg" "$GIT_DIR"/MERGE_MSG || exit
warn warn
warn "Could not apply $1... $2" warn "Could not apply $1... $2"
die_with_patch $1 "" die_with_patch $1 ""
} }
flush_rewritten_pending() { flush_rewritten_pending() {
test -s "$REWRITTEN_PENDING" || return test -s "$rewritten_pending" || return
newsha1="$(git rev-parse HEAD^0)" newsha1="$(git rev-parse HEAD^0)"
sed "s/$/ $newsha1/" < "$REWRITTEN_PENDING" >> "$REWRITTEN_LIST" sed "s/$/ $newsha1/" < "$rewritten_pending" >> "$rewritten_list"
rm -f "$REWRITTEN_PENDING" rm -f "$rewritten_pending"
} }
record_in_rewritten() { record_in_rewritten() {
oldsha1="$(git rev-parse $1)" oldsha1="$(git rev-parse $1)"
echo "$oldsha1" >> "$REWRITTEN_PENDING" echo "$oldsha1" >> "$rewritten_pending"
case "$(peek_next_command)" in case "$(peek_next_command)" in
squash|s|fixup|f) squash|s|fixup|f)
@ -443,8 +443,8 @@ record_in_rewritten() {
} }
do_next () { do_next () {
rm -f "$MSG" "$AUTHOR_SCRIPT" "$AMEND" || exit rm -f "$msg" "$author_script" "$amend" || exit
read -r command sha1 rest < "$TODO" read -r command sha1 rest < "$todo"
case "$command" in case "$command" in
'#'*|''|noop) '#'*|''|noop)
mark_action_done mark_action_done
@ -472,9 +472,9 @@ do_next () {
mark_action_done mark_action_done
pick_one $sha1 || pick_one $sha1 ||
die_with_patch $sha1 "Could not apply $sha1... $rest" die_with_patch $sha1 "Could not apply $sha1... $rest"
echo "$sha1" > "$DOTEST"/stopped-sha echo "$sha1" > "$dotest"/stopped-sha
make_patch $sha1 make_patch $sha1
git rev-parse --verify HEAD > "$AMEND" git rev-parse --verify HEAD > "$amend"
warn "Stopped at $sha1... $rest" warn "Stopped at $sha1... $rest"
warn "You can amend the commit now, with" warn "You can amend the commit now, with"
warn warn
@ -497,47 +497,47 @@ do_next () {
esac esac
comment_for_reflog $squash_style comment_for_reflog $squash_style
test -f "$DONE" && has_action "$DONE" || test -f "$done" && has_action "$done" ||
die "Cannot '$squash_style' without a previous commit" die "Cannot '$squash_style' without a previous commit"
mark_action_done mark_action_done
update_squash_messages $squash_style $sha1 update_squash_messages $squash_style $sha1
author_script=$(get_author_ident_from_commit HEAD) author_script_content=$(get_author_ident_from_commit HEAD)
echo "$author_script" > "$AUTHOR_SCRIPT" echo "$author_script_content" > "$author_script"
eval "$author_script" eval "$author_script_content"
output git reset --soft HEAD^ output git reset --soft HEAD^
pick_one -n $sha1 || die_failed_squash $sha1 "$rest" pick_one -n $sha1 || die_failed_squash $sha1 "$rest"
case "$(peek_next_command)" in case "$(peek_next_command)" in
squash|s|fixup|f) squash|s|fixup|f)
# This is an intermediate commit; its message will only be # This is an intermediate commit; its message will only be
# used in case of trouble. So use the long version: # used in case of trouble. So use the long version:
do_with_author output git commit --no-verify -F "$SQUASH_MSG" || do_with_author output git commit --no-verify -F "$squash_msg" ||
die_failed_squash $sha1 "$rest" die_failed_squash $sha1 "$rest"
;; ;;
*) *)
# This is the final command of this squash/fixup group # This is the final command of this squash/fixup group
if test -f "$FIXUP_MSG" if test -f "$fixup_msg"
then then
do_with_author git commit --no-verify -F "$FIXUP_MSG" || do_with_author git commit --no-verify -F "$fixup_msg" ||
die_failed_squash $sha1 "$rest" die_failed_squash $sha1 "$rest"
else else
cp "$SQUASH_MSG" "$GIT_DIR"/SQUASH_MSG || exit cp "$squash_msg" "$GIT_DIR"/SQUASH_MSG || exit
rm -f "$GIT_DIR"/MERGE_MSG rm -f "$GIT_DIR"/MERGE_MSG
do_with_author git commit --no-verify -e || do_with_author git commit --no-verify -e ||
die_failed_squash $sha1 "$rest" die_failed_squash $sha1 "$rest"
fi fi
rm -f "$SQUASH_MSG" "$FIXUP_MSG" rm -f "$squash_msg" "$fixup_msg"
;; ;;
esac esac
record_in_rewritten $sha1 record_in_rewritten $sha1
;; ;;
x|"exec") x|"exec")
read -r command rest < "$TODO" read -r command rest < "$todo"
mark_action_done mark_action_done
printf 'Executing: %s\n' "$rest" printf 'Executing: %s\n' "$rest"
# "exec" command doesn't take a sha1 in the todo-list. # "exec" command doesn't take a sha1 in the todo-list.
# => can't just use $sha1 here. # => can't just use $sha1 here.
git rev-parse --verify HEAD > "$DOTEST"/stopped-sha git rev-parse --verify HEAD > "$dotest"/stopped-sha
${SHELL:-@SHELL_PATH@} -c "$rest" # Actual execution ${SHELL:-@SHELL_PATH@} -c "$rest" # Actual execution
status=$? status=$?
if test "$status" -ne 0 if test "$status" -ne 0
@ -563,42 +563,42 @@ do_next () {
warn "Unknown command: $command $sha1 $rest" warn "Unknown command: $command $sha1 $rest"
if git rev-parse --verify -q "$sha1" >/dev/null if git rev-parse --verify -q "$sha1" >/dev/null
then then
die_with_patch $sha1 "Please fix this in the file $TODO." die_with_patch $sha1 "Please fix this in the file $todo."
else else
die "Please fix this in the file $TODO." die "Please fix this in the file $todo."
fi fi
;; ;;
esac esac
test -s "$TODO" && return test -s "$todo" && return
comment_for_reflog finish && comment_for_reflog finish &&
HEADNAME=$(cat "$DOTEST"/head-name) && headname=$(cat "$dotest"/head-name) &&
OLDHEAD=$(cat "$DOTEST"/head) && oldhead=$(cat "$dotest"/head) &&
SHORTONTO=$(git rev-parse --short $(cat "$DOTEST"/onto)) && shortonto=$(git rev-parse --short $(cat "$dotest"/onto)) &&
NEWHEAD=$(git rev-parse HEAD) && newhead=$(git rev-parse HEAD) &&
case $HEADNAME in case $headname in
refs/*) refs/*)
message="$GIT_REFLOG_ACTION: $HEADNAME onto $SHORTONTO" && message="$GIT_REFLOG_ACTION: $headname onto $shortonto" &&
git update-ref -m "$message" $HEADNAME $NEWHEAD $OLDHEAD && git update-ref -m "$message" $headname $newhead $oldhead &&
git symbolic-ref HEAD $HEADNAME git symbolic-ref HEAD $headname
;; ;;
esac && { esac && {
test ! -f "$DOTEST"/verbose || test ! -f "$dotest"/verbose ||
git diff-tree --stat $(cat "$DOTEST"/head)..HEAD git diff-tree --stat $(cat "$dotest"/head)..HEAD
} && } &&
{ {
test -s "$REWRITTEN_LIST" && test -s "$rewritten_list" &&
git notes copy --for-rewrite=rebase < "$REWRITTEN_LIST" || git notes copy --for-rewrite=rebase < "$rewritten_list" ||
true # we don't care if this copying failed true # we don't care if this copying failed
} && } &&
if test -x "$GIT_DIR"/hooks/post-rewrite && if test -x "$GIT_DIR"/hooks/post-rewrite &&
test -s "$REWRITTEN_LIST"; then test -s "$rewritten_list"; then
"$GIT_DIR"/hooks/post-rewrite rebase < "$REWRITTEN_LIST" "$GIT_DIR"/hooks/post-rewrite rebase < "$rewritten_list"
true # we don't care if this hook failed true # we don't care if this hook failed
fi && fi &&
rm -rf "$DOTEST" && rm -rf "$dotest" &&
git gc --auto && git gc --auto &&
warn "Successfully rebased and updated $HEADNAME." warn "Successfully rebased and updated $headname."
exit exit
} }
@ -618,11 +618,11 @@ skip_unnecessary_picks () {
# fd=3 means we skip the command # fd=3 means we skip the command
case "$fd,$command" in case "$fd,$command" in
3,pick|3,p) 3,pick|3,p)
# pick a commit whose parent is current $ONTO -> skip # pick a commit whose parent is current $onto -> skip
sha1=${rest%% *} sha1=${rest%% *}
case "$(git rev-parse --verify --quiet "$sha1"^)" in case "$(git rev-parse --verify --quiet "$sha1"^)" in
"$ONTO"*) "$onto"*)
ONTO=$sha1 onto=$sha1
;; ;;
*) *)
fd=1 fd=1
@ -637,11 +637,11 @@ skip_unnecessary_picks () {
;; ;;
esac esac
printf '%s\n' "$command${rest:+ }$rest" >&$fd printf '%s\n' "$command${rest:+ }$rest" >&$fd
done <"$TODO" >"$TODO.new" 3>>"$DONE" && done <"$todo" >"$todo.new" 3>>"$done" &&
mv -f "$TODO".new "$TODO" && mv -f "$todo".new "$todo" &&
case "$(peek_next_command)" in case "$(peek_next_command)" in
squash|s|fixup|f) squash|s|fixup|f)
record_in_rewritten "$ONTO" record_in_rewritten "$onto"
;; ;;
esac || esac ||
die "Could not skip unnecessary pick commands" die "Could not skip unnecessary pick commands"
@ -650,17 +650,17 @@ skip_unnecessary_picks () {
# check if no other options are set # check if no other options are set
is_standalone () { is_standalone () {
test $# -eq 2 -a "$2" = '--' && test $# -eq 2 -a "$2" = '--' &&
test -z "$ONTO" && test -z "$onto" &&
test -z "$PRESERVE_MERGES" && test -z "$preserve_merges" &&
test -z "$STRATEGY" && test -z "$strategy" &&
test -z "$VERBOSE" test -z "$verbose"
} }
get_saved_options () { get_saved_options () {
test -d "$REWRITTEN" && PRESERVE_MERGES=t test -d "$rewritten" && preserve_merges=t
test -f "$DOTEST"/strategy && STRATEGY="$(cat "$DOTEST"/strategy)" test -f "$dotest"/strategy && strategy="$(cat "$dotest"/strategy)"
test -f "$DOTEST"/verbose && VERBOSE=t test -f "$dotest"/verbose && verbose=t
test -f "$DOTEST"/rebase-root && REBASE_ROOT=t test -f "$dotest"/rebase-root && rebase_root=t
} }
# Rearrange the todo list that has both "pick sha1 msg" and # Rearrange the todo list that has both "pick sha1 msg" and
@ -699,7 +699,7 @@ rearrange_squash () {
esac esac
printf '%s\n' "$pick $sha1 $message" printf '%s\n' "$pick $sha1 $message"
used="$used$sha1 " used="$used$sha1 "
while read -r squash action msg while read -r squash action msg_content
do do
case " $used" in case " $used" in
*" $squash "*) continue ;; *" $squash "*) continue ;;
@ -709,13 +709,13 @@ rearrange_squash () {
+*) +*)
action="${action#+}" action="${action#+}"
# full sha1 prefix test # full sha1 prefix test
case "$msg" in "$sha1"*) emit=1;; esac ;; case "$msg_content" in "$sha1"*) emit=1;; esac ;;
*) *)
# message prefix test # message prefix test
case "$message" in "$msg"*) emit=1;; esac ;; case "$message" in "$msg_content"*) emit=1;; esac ;;
esac esac
if test $emit = 1; then if test $emit = 1; then
printf '%s\n' "$action $squash $action! $msg" printf '%s\n' "$action $squash $action! $msg_content"
used="$used$squash " used="$used$squash "
fi fi
done <"$1.sq" done <"$1.sq"
@ -747,17 +747,17 @@ while test $# != 0
do do
case "$1" in case "$1" in
--no-verify) --no-verify)
OK_TO_SKIP_PRE_REBASE=yes ok_to_skip_pre_rebase=yes
;; ;;
--verify) --verify)
OK_TO_SKIP_PRE_REBASE= ok_to_skip_pre_rebase=
;; ;;
--continue) --continue)
is_standalone "$@" || usage is_standalone "$@" || usage
get_saved_options get_saved_options
comment_for_reflog continue comment_for_reflog continue
test -d "$DOTEST" || die "No interactive rebase running" test -d "$dotest" || die "No interactive rebase running"
# Sanity check # Sanity check
git rev-parse --verify HEAD >/dev/null || git rev-parse --verify HEAD >/dev/null ||
@ -771,26 +771,26 @@ do
then then
: Nothing to commit -- skip this : Nothing to commit -- skip this
else else
. "$AUTHOR_SCRIPT" || . "$author_script" ||
die "Cannot find the author identity" die "Cannot find the author identity"
amend= current_head=
if test -f "$AMEND" if test -f "$amend"
then then
amend=$(git rev-parse --verify HEAD) current_head=$(git rev-parse --verify HEAD)
test "$amend" = $(cat "$AMEND") || test "$current_head" = $(cat "$amend") ||
die "\ die "\
You have uncommitted changes in your working tree. Please, commit them You have uncommitted changes in your working tree. Please, commit them
first and then run 'git rebase --continue' again." first and then run 'git rebase --continue' again."
git reset --soft HEAD^ || git reset --soft HEAD^ ||
die "Cannot rewind the HEAD" die "Cannot rewind the HEAD"
fi fi
do_with_author git commit --no-verify -F "$MSG" -e || { do_with_author git commit --no-verify -F "$msg" -e || {
test -n "$amend" && git reset --soft $amend test -n "$current_head" && git reset --soft $current_head
die "Could not commit staged changes." die "Could not commit staged changes."
} }
fi fi
record_in_rewritten "$(cat "$DOTEST"/stopped-sha)" record_in_rewritten "$(cat "$dotest"/stopped-sha)"
require_clean_work_tree "rebase" require_clean_work_tree "rebase"
do_rest do_rest
@ -801,17 +801,17 @@ first and then run 'git rebase --continue' again."
comment_for_reflog abort comment_for_reflog abort
git rerere clear git rerere clear
test -d "$DOTEST" || die "No interactive rebase running" test -d "$dotest" || die "No interactive rebase running"
HEADNAME=$(cat "$DOTEST"/head-name) headname=$(cat "$dotest"/head-name)
HEAD=$(cat "$DOTEST"/head) head=$(cat "$dotest"/head)
case $HEADNAME in case $headname in
refs/*) refs/*)
git symbolic-ref HEAD $HEADNAME git symbolic-ref HEAD $headname
;; ;;
esac && esac &&
output git reset --hard $HEAD && output git reset --hard $head &&
rm -rf "$DOTEST" rm -rf "$dotest"
exit exit
;; ;;
--skip) --skip)
@ -820,18 +820,18 @@ first and then run 'git rebase --continue' again."
comment_for_reflog skip comment_for_reflog skip
git rerere clear git rerere clear
test -d "$DOTEST" || die "No interactive rebase running" test -d "$dotest" || die "No interactive rebase running"
output git reset --hard && do_rest output git reset --hard && do_rest
;; ;;
-s) -s)
case "$#,$1" in case "$#,$1" in
*,*=*) *,*=*)
STRATEGY="-s "$(expr "z$1" : 'z-[^=]*=\(.*\)') ;; strategy="-s "$(expr "z$1" : 'z-[^=]*=\(.*\)') ;;
1,*) 1,*)
usage ;; usage ;;
*) *)
STRATEGY="-s $2" strategy="-s $2"
shift ;; shift ;;
esac esac
;; ;;
@ -839,29 +839,29 @@ first and then run 'git rebase --continue' again."
# we use merge anyway # we use merge anyway
;; ;;
-v) -v)
VERBOSE=t verbose=t
;; ;;
-p) -p)
PRESERVE_MERGES=t preserve_merges=t
;; ;;
-i) -i)
# yeah, we know # yeah, we know
;; ;;
--no-ff) --no-ff)
NEVER_FF=t force_rebase=t
;; ;;
--root) --root)
REBASE_ROOT=t rebase_root=t
;; ;;
--autosquash) --autosquash)
AUTOSQUASH=t autosquash=t
;; ;;
--no-autosquash) --no-autosquash)
AUTOSQUASH= autosquash=
;; ;;
--onto) --onto)
shift shift
ONTO=$(parse_onto "$1") || onto=$(parse_onto "$1") ||
die "Does not point to a valid commit: $1" die "Does not point to a valid commit: $1"
;; ;;
--) --)
@ -872,27 +872,27 @@ first and then run 'git rebase --continue' again."
shift shift
done done
test -z "$REBASE_ROOT" -a $# -ge 1 -a $# -le 2 || test -z "$rebase_root" -a $# -ge 1 -a $# -le 2 ||
test ! -z "$REBASE_ROOT" -a $# -le 1 || usage test ! -z "$rebase_root" -a $# -le 1 || usage
test -d "$DOTEST" && test -d "$dotest" &&
die "Interactive rebase already started" die "Interactive rebase already started"
git var GIT_COMMITTER_IDENT >/dev/null || git var GIT_COMMITTER_IDENT >/dev/null ||
die "You need to set your committer info first" die "You need to set your committer info first"
if test -z "$REBASE_ROOT" if test -z "$rebase_root"
then then
UPSTREAM_ARG="$1" upstream_arg="$1"
UPSTREAM=$(git rev-parse --verify "$1") || die "Invalid base" upstream=$(git rev-parse --verify "$1") || die "Invalid base"
test -z "$ONTO" && ONTO=$UPSTREAM test -z "$onto" && onto=$upstream
shift shift
else else
UPSTREAM= upstream=
UPSTREAM_ARG=--root upstream_arg=--root
test -z "$ONTO" && test -z "$onto" &&
die "You must specify --onto when using --root" die "You must specify --onto when using --root"
fi fi
run_pre_rebase_hook "$UPSTREAM_ARG" "$@" run_pre_rebase_hook "$upstream_arg" "$@"
comment_for_reflog start comment_for_reflog start
@ -904,76 +904,76 @@ then
die "Could not checkout $1" die "Could not checkout $1"
fi fi
HEAD=$(git rev-parse --verify HEAD) || die "No HEAD?" head=$(git rev-parse --verify HEAD) || die "No HEAD?"
mkdir "$DOTEST" || die "Could not create temporary $DOTEST" mkdir "$dotest" || die "Could not create temporary $dotest"
: > "$DOTEST"/interactive || die "Could not mark as interactive" : > "$dotest"/interactive || die "Could not mark as interactive"
git symbolic-ref HEAD > "$DOTEST"/head-name 2> /dev/null || git symbolic-ref HEAD > "$dotest"/head-name 2> /dev/null ||
echo "detached HEAD" > "$DOTEST"/head-name echo "detached HEAD" > "$dotest"/head-name
echo $HEAD > "$DOTEST"/head echo $head > "$dotest"/head
case "$REBASE_ROOT" in case "$rebase_root" in
'') '')
rm -f "$DOTEST"/rebase-root ;; rm -f "$dotest"/rebase-root ;;
*) *)
: >"$DOTEST"/rebase-root ;; : >"$dotest"/rebase-root ;;
esac esac
echo $ONTO > "$DOTEST"/onto echo $onto > "$dotest"/onto
test -z "$STRATEGY" || echo "$STRATEGY" > "$DOTEST"/strategy test -z "$strategy" || echo "$strategy" > "$dotest"/strategy
test t = "$VERBOSE" && : > "$DOTEST"/verbose test t = "$verbose" && : > "$dotest"/verbose
if test t = "$PRESERVE_MERGES" if test t = "$preserve_merges"
then then
if test -z "$REBASE_ROOT" if test -z "$rebase_root"
then then
mkdir "$REWRITTEN" && mkdir "$rewritten" &&
for c in $(git merge-base --all $HEAD $UPSTREAM) for c in $(git merge-base --all $head $upstream)
do do
echo $ONTO > "$REWRITTEN"/$c || echo $onto > "$rewritten"/$c ||
die "Could not init rewritten commits" die "Could not init rewritten commits"
done done
else else
mkdir "$REWRITTEN" && mkdir "$rewritten" &&
echo $ONTO > "$REWRITTEN"/root || echo $onto > "$rewritten"/root ||
die "Could not init rewritten commits" die "Could not init rewritten commits"
fi fi
# No cherry-pick because our first pass is to determine # No cherry-pick because our first pass is to determine
# parents to rewrite and skipping dropped commits would # parents to rewrite and skipping dropped commits would
# prematurely end our probe # prematurely end our probe
MERGES_OPTION= merges_option=
first_after_upstream="$(git rev-list --reverse --first-parent $UPSTREAM..$HEAD | head -n 1)" first_after_upstream="$(git rev-list --reverse --first-parent $upstream..$head | head -n 1)"
else else
MERGES_OPTION="--no-merges --cherry-pick" merges_option="--no-merges --cherry-pick"
fi fi
SHORTHEAD=$(git rev-parse --short $HEAD) shorthead=$(git rev-parse --short $head)
SHORTONTO=$(git rev-parse --short $ONTO) shortonto=$(git rev-parse --short $onto)
if test -z "$REBASE_ROOT" if test -z "$rebase_root"
# this is now equivalent to ! -z "$UPSTREAM" # this is now equivalent to ! -z "$upstream"
then then
SHORTUPSTREAM=$(git rev-parse --short $UPSTREAM) shortupstream=$(git rev-parse --short $upstream)
REVISIONS=$UPSTREAM...$HEAD revisions=$upstream...$head
SHORTREVISIONS=$SHORTUPSTREAM..$SHORTHEAD shortrevisions=$shortupstream..$shorthead
else else
REVISIONS=$ONTO...$HEAD revisions=$onto...$head
SHORTREVISIONS=$SHORTHEAD shortrevisions=$shorthead
fi fi
git rev-list $MERGES_OPTION --pretty=oneline --abbrev-commit \ git rev-list $merges_option --pretty=oneline --abbrev-commit \
--abbrev=7 --reverse --left-right --topo-order \ --abbrev=7 --reverse --left-right --topo-order \
$REVISIONS | \ $revisions | \
sed -n "s/^>//p" | sed -n "s/^>//p" |
while read -r shortsha1 rest while read -r shortsha1 rest
do do
if test t != "$PRESERVE_MERGES" if test t != "$preserve_merges"
then then
printf '%s\n' "pick $shortsha1 $rest" >> "$TODO" printf '%s\n' "pick $shortsha1 $rest" >> "$todo"
else else
sha1=$(git rev-parse $shortsha1) sha1=$(git rev-parse $shortsha1)
if test -z "$REBASE_ROOT" if test -z "$rebase_root"
then then
preserve=t preserve=t
for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-) for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)
do do
if test -f "$REWRITTEN"/$p -a \( $p != $ONTO -o $sha1 = $first_after_upstream \) if test -f "$rewritten"/$p -a \( $p != $onto -o $sha1 = $first_after_upstream \)
then then
preserve=f preserve=f
fi fi
@ -983,43 +983,43 @@ do
fi fi
if test f = "$preserve" if test f = "$preserve"
then then
touch "$REWRITTEN"/$sha1 touch "$rewritten"/$sha1
printf '%s\n' "pick $shortsha1 $rest" >> "$TODO" printf '%s\n' "pick $shortsha1 $rest" >> "$todo"
fi fi
fi fi
done done
# Watch for commits that been dropped by --cherry-pick # Watch for commits that been dropped by --cherry-pick
if test t = "$PRESERVE_MERGES" if test t = "$preserve_merges"
then then
mkdir "$DROPPED" mkdir "$dropped"
# Save all non-cherry-picked changes # Save all non-cherry-picked changes
git rev-list $REVISIONS --left-right --cherry-pick | \ git rev-list $revisions --left-right --cherry-pick | \
sed -n "s/^>//p" > "$DOTEST"/not-cherry-picks sed -n "s/^>//p" > "$dotest"/not-cherry-picks
# Now all commits and note which ones are missing in # Now all commits and note which ones are missing in
# not-cherry-picks and hence being dropped # not-cherry-picks and hence being dropped
git rev-list $REVISIONS | git rev-list $revisions |
while read rev while read rev
do do
if test -f "$REWRITTEN"/$rev -a "$(sane_grep "$rev" "$DOTEST"/not-cherry-picks)" = "" if test -f "$rewritten"/$rev -a "$(sane_grep "$rev" "$dotest"/not-cherry-picks)" = ""
then then
# Use -f2 because if rev-list is telling us this commit is # Use -f2 because if rev-list is telling us this commit is
# not worthwhile, we don't want to track its multiple heads, # not worthwhile, we don't want to track its multiple heads,
# just the history of its first-parent for others that will # just the history of its first-parent for others that will
# be rebasing on top of it # be rebasing on top of it
git rev-list --parents -1 $rev | cut -d' ' -s -f2 > "$DROPPED"/$rev git rev-list --parents -1 $rev | cut -d' ' -s -f2 > "$dropped"/$rev
short=$(git rev-list -1 --abbrev-commit --abbrev=7 $rev) short=$(git rev-list -1 --abbrev-commit --abbrev=7 $rev)
sane_grep -v "^[a-z][a-z]* $short" <"$TODO" > "${TODO}2" ; mv "${TODO}2" "$TODO" sane_grep -v "^[a-z][a-z]* $short" <"$todo" > "${todo}2" ; mv "${todo}2" "$todo"
rm "$REWRITTEN"/$rev rm "$rewritten"/$rev
fi fi
done done
fi fi
test -s "$TODO" || echo noop >> "$TODO" test -s "$todo" || echo noop >> "$todo"
test -n "$AUTOSQUASH" && rearrange_squash "$TODO" test -n "$autosquash" && rearrange_squash "$todo"
cat >> "$TODO" << EOF cat >> "$todo" << EOF
# Rebase $SHORTREVISIONS onto $SHORTONTO # Rebase $shortrevisions onto $shortonto
# #
# Commands: # Commands:
# p, pick = use commit # p, pick = use commit
@ -1034,18 +1034,18 @@ cat >> "$TODO" << EOF
# #
EOF EOF
has_action "$TODO" || has_action "$todo" ||
die_abort "Nothing to do" die_abort "Nothing to do"
cp "$TODO" "$TODO".backup cp "$todo" "$todo".backup
git_editor "$TODO" || git_editor "$todo" ||
die_abort "Could not execute editor" die_abort "Could not execute editor"
has_action "$TODO" || has_action "$todo" ||
die_abort "Nothing to do" die_abort "Nothing to do"
test -d "$REWRITTEN" || test -n "$NEVER_FF" || skip_unnecessary_picks test -d "$rewritten" || test -n "$force_rebase" || skip_unnecessary_picks
output git checkout $ONTO || die_abort "could not detach HEAD" output git checkout $onto || die_abort "could not detach HEAD"
git update-ref ORIG_HEAD $HEAD git update-ref ORIG_HEAD $head
do_rest do_rest

32
git-rebase.sh
View File

@ -36,13 +36,13 @@ cd_to_toplevel
LF=' LF='
' '
OK_TO_SKIP_PRE_REBASE= ok_to_skip_pre_rebase=
RESOLVEMSG=" resolvemsg="
When you have resolved this problem run \"git rebase --continue\". When you have resolved this problem run \"git rebase --continue\".
If you would prefer to skip this patch, instead run \"git rebase --skip\". 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\". To restore the original branch and stop rebasing run \"git rebase --abort\".
" "
unset newbase unset onto
strategy=recursive strategy=recursive
strategy_opts= strategy_opts=
do_merge= do_merge=
@ -86,7 +86,7 @@ continue_merge () {
then then
echo "You still have unmerged paths in your index" echo "You still have unmerged paths in your index"
echo "did you forget to use git add?" echo "did you forget to use git add?"
die "$RESOLVEMSG" die "$resolvemsg"
fi fi
cmt=`cat "$merge_dir/current"` cmt=`cat "$merge_dir/current"`
@ -96,7 +96,7 @@ continue_merge () {
then then
echo "Commit failed, please do not call \"git commit\"" echo "Commit failed, please do not call \"git commit\""
echo "directly, but instead do one of the following: " echo "directly, but instead do one of the following: "
die "$RESOLVEMSG" die "$resolvemsg"
fi fi
if test -z "$GIT_QUIET" if test -z "$GIT_QUIET"
then then
@ -139,11 +139,11 @@ call_merge () {
;; ;;
1) 1)
git rerere $allow_rerere_autoupdate git rerere $allow_rerere_autoupdate
die "$RESOLVEMSG" die "$resolvemsg"
;; ;;
2) 2)
echo "Strategy: $rv $strategy failed, try another" 1>&2 echo "Strategy: $rv $strategy failed, try another" 1>&2
die "$RESOLVEMSG" die "$resolvemsg"
;; ;;
*) *)
die "Unknown exit code ($rv) from command:" \ die "Unknown exit code ($rv) from command:" \
@ -199,7 +199,7 @@ is_interactive () {
} }
run_pre_rebase_hook () { run_pre_rebase_hook () {
if test -z "$OK_TO_SKIP_PRE_REBASE" && if test -z "$ok_to_skip_pre_rebase" &&
test -x "$GIT_DIR/hooks/pre-rebase" test -x "$GIT_DIR/hooks/pre-rebase"
then then
"$GIT_DIR/hooks/pre-rebase" ${1+"$@"} || "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} ||
@ -234,10 +234,10 @@ while test $# != 0
do do
case "$1" in case "$1" in
--no-verify) --no-verify)
OK_TO_SKIP_PRE_REBASE=yes ok_to_skip_pre_rebase=yes
;; ;;
--verify) --verify)
OK_TO_SKIP_PRE_REBASE= ok_to_skip_pre_rebase=
;; ;;
--continue|--skip|--abort) --continue|--skip|--abort)
test $total_argc -eq 1 || usage test $total_argc -eq 1 || usage
@ -245,7 +245,7 @@ do
;; ;;
--onto) --onto)
test 2 -le "$#" || usage test 2 -le "$#" || usage
newbase="$2" onto="$2"
shift shift
;; ;;
-M|-m|--m|--me|--mer|--merg|--merge) -M|-m|--m|--me|--mer|--merg|--merge)
@ -359,7 +359,7 @@ continue)
finish_rb_merge finish_rb_merge
exit exit
fi fi
git am --resolved --3way --resolvemsg="$RESOLVEMSG" && git am --resolved --3way --resolvemsg="$resolvemsg" &&
move_to_original_branch move_to_original_branch
exit exit
;; ;;
@ -378,7 +378,7 @@ skip)
finish_rb_merge finish_rb_merge
exit exit
fi fi
git am -3 --skip --resolvemsg="$RESOLVEMSG" && git am -3 --skip --resolvemsg="$resolvemsg" &&
move_to_original_branch move_to_original_branch
exit exit
;; ;;
@ -425,7 +425,7 @@ then
unset root_flag unset root_flag
upstream_arg="$upstream_name" upstream_arg="$upstream_name"
else else
test -z "$newbase" && die "--root must be used with --onto" test -z "$onto" && die "--root must be used with --onto"
unset upstream_name unset upstream_name
unset upstream unset upstream
root_flag="--root" root_flag="--root"
@ -433,7 +433,7 @@ else
fi fi
# Make sure the branch to rebase onto is valid. # Make sure the branch to rebase onto is valid.
onto_name=${newbase-"$upstream_name"} onto_name=${onto-"$upstream_name"}
case "$onto_name" in case "$onto_name" in
*...*) *...*)
if left=${onto_name%...*} right=${onto_name#*...} && if left=${onto_name%...*} right=${onto_name#*...} &&
@ -554,7 +554,7 @@ then
git format-patch -k --stdout --full-index --ignore-if-in-upstream \ git format-patch -k --stdout --full-index --ignore-if-in-upstream \
--src-prefix=a/ --dst-prefix=b/ \ --src-prefix=a/ --dst-prefix=b/ \
--no-renames $root_flag "$revisions" | --no-renames $root_flag "$revisions" |
git am $git_am_opt --rebasing --resolvemsg="$RESOLVEMSG" && git am $git_am_opt --rebasing --resolvemsg="$resolvemsg" &&
move_to_original_branch move_to_original_branch
ret=$? ret=$?
test 0 != $ret -a -d "$apply_dir" && test 0 != $ret -a -d "$apply_dir" &&