* [PATCH v2 26/31] rebase: remember strategy and strategy options
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
When a rebase is resumed, interactive rebase remembers any merge
strategy passed when the rebase was initated. Make non-interactive
rebase remember any merge strategy as well. Also make non-interactive
rebase remember any merge strategy options.
To be able to resume a rebase that was initiated with an older version
of git (older than this commit), make sure not to expect the saved
option files to exist.
Test case idea taken from Junio's 71fc224 (t3402: test "rebase
-s<strategy> -X<opt>", 2010-11-11).
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
git-rebase--interactive.sh | 2 --
git-rebase.sh | 6 ++++++
t/t3418-rebase-continue.sh | 29 +++++++++++++++++++++++++++++
3 files changed, 35 insertions(+), 2 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index f076a6e..5773b75 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -584,7 +584,6 @@ skip_unnecessary_picks () {
get_saved_options () {
test -d "$rewritten" && preserve_merges=t
- test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
test -f "$state_dir"/rebase-root && rebase_root=t
}
@@ -713,7 +712,6 @@ case "$rebase_root" in
*)
: >"$state_dir"/rebase-root ;;
esac
-test -z "$strategy" || echo "$strategy" > "$state_dir"/strategy
if test t = "$preserve_merges"
then
if test -z "$rebase_root"
diff --git a/git-rebase.sh b/git-rebase.sh
index 8a36e7a..f4ad7c1 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -81,6 +81,9 @@ read_basic_state () {
fi &&
GIT_QUIET=$(cat "$state_dir"/quiet) &&
test -f "$state_dir"/verbose && verbose=t
+ test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
+ test -f "$state_dir"/strategy_opts &&
+ strategy_opts="$(cat "$state_dir"/strategy_opts)"
}
write_basic_state () {
@@ -89,6 +92,9 @@ write_basic_state () {
echo "$orig_head" > "$state_dir"/orig-head &&
echo "$GIT_QUIET" > "$state_dir"/quiet &&
test t = "$verbose" && : > "$state_dir"/verbose
+ test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
+ test -n "$strategy_opts" && echo "$strategy_opts" > \
+ "$state_dir"/strategy_opts
}
output () {
diff --git a/t/t3418-rebase-continue.sh b/t/t3418-rebase-continue.sh
index 1d90191..5469546 100755
--- a/t/t3418-rebase-continue.sh
+++ b/t/t3418-rebase-continue.sh
@@ -45,4 +45,33 @@ test_expect_success 'rebase --continue can not be used with other options' '
test_must_fail git rebase --continue -v
'
+test_expect_success 'rebase --continue remembers merge strategy and options' '
+ rm -fr .git/rebase-* &&
+ git reset --hard commit-new-file-F2-on-topic-branch &&
+ test_commit "commit-new-file-F3-on-topic-branch" F3 32 &&
+ test_when_finished "rm -fr test-bin funny.was.run" &&
+ mkdir test-bin &&
+ cat >test-bin/git-merge-funny <<-EOF
+ #!$SHELL_PATH
+ case "\$1" in --opt) ;; *) exit 2 ;; esac
+ shift &&
+ >funny.was.run &&
+ exec git merge-recursive "\$@"
+ EOF
+ chmod +x test-bin/git-merge-funny &&
+ (
+ PATH=./test-bin:$PATH
+ test_must_fail git rebase -s funny -Xopt master topic
+ ) &&
+ test -f funny.was.run &&
+ rm funny.was.run &&
+ echo "Resolved" >F2 &&
+ git add F2 &&
+ (
+ PATH=./test-bin:$PATH
+ git rebase --continue
+ ) &&
+ test -f funny.was.run
+'
+
test_done
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 23/31] rebase: factor out sub command handling
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
Factor out the common parts of the handling of the sub commands
'--continue', '--skip' and '--abort'. The '--abort' handling can
handled completely in git-rebase.sh.
After this refactoring, the calls to git-rebase--am.sh,
git-rebase--merge.sh and git-rebase--interactive.sh will be better
aligned. There will only be one call to interactive rebase that will
shortcut the very last part of git-rebase.sh.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
git-rebase--interactive.sh | 34 +++-------------------------------
git-rebase.sh | 17 +++++++++++++++--
2 files changed, 18 insertions(+), 33 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index affa467..4af0bc6 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -509,9 +509,7 @@ do_next () {
test -s "$todo" && return
comment_for_reflog finish &&
- head_name=$(cat "$state_dir"/head-name) &&
- orig_head=$(cat "$state_dir"/head) &&
- shortonto=$(git rev-parse --short $(cat "$state_dir"/onto)) &&
+ shortonto=$(git rev-parse --short $onto) &&
newhead=$(git rev-parse HEAD) &&
case $head_name in
refs/*)
@@ -521,7 +519,7 @@ do_next () {
;;
esac && {
test ! -f "$state_dir"/verbose ||
- git diff-tree --stat $(cat "$state_dir"/head)..HEAD
+ git diff-tree --stat $orig_head..HEAD
} &&
{
test -s "$rewritten_list" &&
@@ -655,14 +653,6 @@ rearrange_squash () {
case "$action" in
continue)
get_saved_options
- comment_for_reflog continue
-
- # Sanity check
- git rev-parse --verify HEAD >/dev/null ||
- die "Cannot read HEAD"
- git update-index --ignore-submodules --refresh &&
- git diff-files --quiet --ignore-submodules ||
- die "Working tree is dirty"
# do we have anything to commit?
if git diff-index --cached --quiet --ignore-submodules HEAD --
@@ -693,30 +683,12 @@ first and then run 'git rebase --continue' again."
require_clean_work_tree "rebase"
do_rest
;;
-abort)
- get_saved_options
- comment_for_reflog abort
-
- git rerere clear
-
- head_name=$(cat "$state_dir"/head-name)
- orig_head=$(cat "$state_dir"/head)
- case $head_name in
- refs/*)
- git symbolic-ref HEAD $head_name
- ;;
- esac &&
- output git reset --hard $orig_head &&
- rm -rf "$state_dir"
- exit
- ;;
skip)
get_saved_options
- comment_for_reflog skip
git rerere clear
- output git reset --hard && do_rest
+ do_rest
;;
esac
diff --git a/git-rebase.sh b/git-rebase.sh
index 42d635b..21bb027 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -70,7 +70,12 @@ test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
read_basic_state () {
head_name=$(cat "$state_dir"/head-name) &&
onto=$(cat "$state_dir"/onto) &&
- orig_head=$(cat "$state_dir"/orig-head) &&
+ if test "$type" = interactive
+ then
+ orig_head=$(cat "$state_dir"/head)
+ else
+ orig_head=$(cat "$state_dir"/orig-head)
+ fi &&
GIT_QUIET=$(cat "$state_dir"/quiet)
}
@@ -262,11 +267,19 @@ test $# -gt 2 && usage
if test -n "$action"
then
test -z "$in_progress" && die "No rebase in progress?"
- test "$type" = interactive && run_specific_rebase
+ # Only interactive rebase uses detailed reflog messages
+ if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
+ then
+ GIT_REFLOG_ACTION="rebase -i ($action)"
+ export GIT_REFLOG_ACTION
+ fi
fi
case "$action" in
continue)
+ # Sanity check
+ git rev-parse --verify HEAD >/dev/null ||
+ die "Cannot read HEAD"
git update-index --ignore-submodules --refresh &&
git diff-files --quiet --ignore-submodules || {
echo "You must edit all merge conflicts and then"
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 22/31] rebase: make -v a tiny bit more verbose
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
To make it possible to later remove the handling of --abort from
git-rebase--interactive.sh, align the implementation in git-rebase.sh
with the former by making it a bit more verbose.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
What do we really want to print when -v is passed? Interactive rebase
is currently quite a bit more verbose than non-interactive rebase.
git-rebase--interactive.sh | 14 --------------
git-rebase.sh | 18 ++++++++++++++++--
2 files changed, 16 insertions(+), 16 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index fa8bfda..affa467 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -86,20 +86,6 @@ warn () {
printf '%s\n' "$*" >&2
}
-output () {
- case "$verbose" in
- '')
- output=$("$@" 2>&1 )
- status=$?
- test $status != 0 && printf "%s\n" "$output"
- return $status
- ;;
- *)
- "$@"
- ;;
- esac
-}
-
# Output the commit message for the specified commit.
commit_message () {
git cat-file commit "$1" | sed "1,/^$/d"
diff --git a/git-rebase.sh b/git-rebase.sh
index c60221b..42d635b 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -74,6 +74,20 @@ read_basic_state () {
GIT_QUIET=$(cat "$state_dir"/quiet)
}
+output () {
+ case "$verbose" in
+ '')
+ output=$("$@" 2>&1 )
+ status=$?
+ test $status != 0 && printf "%s\n" "$output"
+ return $status
+ ;;
+ *)
+ "$@"
+ ;;
+ esac
+}
+
move_to_original_branch () {
case "$head_name" in
refs/*)
@@ -263,7 +277,7 @@ continue)
run_specific_rebase
;;
skip)
- git reset --hard HEAD || exit $?
+ output git reset --hard HEAD || exit $?
read_basic_state
run_specific_rebase
;;
@@ -276,7 +290,7 @@ abort)
die "Could not move back to $head_name"
;;
esac
- git reset --hard $orig_head
+ output git reset --hard $orig_head
rm -r "$state_dir"
exit
;;
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 21/31] rebase -i: align variable names
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
Rename variables HEAD and OLDHEAD to orig_head and HEADNAME to
head_name, which are the names used in git-rebase.sh. This prepares
for factoring out of the code that persists these variables during the
entire rebase process. Using the same variable names to mean the same
thing in both files also makes the code easier to read.
While at it, also remove the DOTEST variable and use the state_dir
variable that was inherited from git-rebase.sh instead.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
git-rebase--interactive.sh | 120 +++++++++++++++++++++----------------------
1 files changed, 59 insertions(+), 61 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index 0499f9e..fa8bfda 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -12,22 +12,20 @@
. git-sh-setup
-dotest="$GIT_DIR/rebase-merge"
-
# The file containing rebase commands, comments, and empty lines.
# 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
# file and written to the tail of $done.
-todo="$dotest"/git-rebase-todo
+todo="$state_dir"/git-rebase-todo
# The rebase command lines that have already been processed. A line
# is moved here when it is first handled, before any associated user
# actions.
-done="$dotest"/done
+done="$state_dir"/done
# The commit message that is planned to be used for any changes that
# need to be committed following a user interaction.
-msg="$dotest"/message
+msg="$state_dir"/message
# The file into which is accumulated the suggested commit message for
# squash/fixup commands. When the first of a series of squash/fixups
@@ -42,14 +40,14 @@ msg="$dotest"/message
# written to the file so far (including the initial "pick" commit).
# Each time that a commit message is processed, this line is read and
# updated. It is deleted just before the combined commit is made.
-squash_msg="$dotest"/message-squash
+squash_msg="$state_dir"/message-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
# original "pick" commit. (If the series ends without a "squash"
# command, then this can be used as the commit message of the combined
# commit without opening the editor.)
-fixup_msg="$dotest"/message-fixup
+fixup_msg="$state_dir"/message-fixup
# $rewritten is the name of a directory containing files for each
# commit that is reachable by at least one merge base of $head and
@@ -57,14 +55,14 @@ fixup_msg="$dotest"/message-fixup
# might be. This ensures that commits on merged, but otherwise
# unrelated side branches are left alone. (Think "X" in the man page's
# example.)
-rewritten="$dotest"/rewritten
+rewritten="$state_dir"/rewritten
-dropped="$dotest"/dropped
+dropped="$state_dir"/dropped
# 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
# being rebased.
-author_script="$dotest"/author-script
+author_script="$state_dir"/author-script
# When an "edit" rebase command is being processed, the SHA1 of the
# commit to be edited is recorded in this file. When "git rebase
@@ -72,14 +70,14 @@ author_script="$dotest"/author-script
# will be amended to the HEAD commit, but only provided the HEAD
# commit is still the commit to be edited. When any other rebase
# command is processed, this file is deleted.
-amend="$dotest"/amend
+amend="$state_dir"/amend
# For the post-rewrite hook, we make a list of rewritten commits and
# their new sha1s. The rewritten-pending list keeps the sha1s of
# commits that have been processed, but not committed yet,
# e.g. because they are waiting for a 'squash' command.
-rewritten_list="$dotest"/rewritten-list
-rewritten_pending="$dotest"/rewritten-pending
+rewritten_list="$state_dir"/rewritten-list
+rewritten_pending="$state_dir"/rewritten-pending
GIT_CHERRY_PICK_HELP="$resolvemsg"
export GIT_CHERRY_PICK_HELP
@@ -145,7 +143,7 @@ make_patch () {
*)
echo "Root commit"
;;
- esac > "$dotest"/patch
+ esac > "$state_dir"/patch
test -f "$msg" ||
commit_message "$1" > "$msg"
test -f "$author_script" ||
@@ -153,14 +151,14 @@ make_patch () {
}
die_with_patch () {
- echo "$1" > "$dotest"/stopped-sha
+ echo "$1" > "$state_dir"/stopped-sha
make_patch "$1"
git rerere
die "$2"
}
die_abort () {
- rm -rf "$dotest"
+ rm -rf "$state_dir"
die "$1"
}
@@ -205,20 +203,20 @@ pick_one_preserving_merges () {
esac
sha1=$(git rev-parse $sha1)
- if test -f "$dotest"/current-commit
+ if test -f "$state_dir"/current-commit
then
if test "$fast_forward" = t
then
while read current_commit
do
git rev-parse HEAD > "$rewritten"/$current_commit
- done <"$dotest"/current-commit
- rm "$dotest"/current-commit ||
+ done <"$state_dir"/current-commit
+ rm "$state_dir"/current-commit ||
die "Cannot write current commit's replacement sha1"
fi
fi
- echo $sha1 >> "$dotest"/current-commit
+ echo $sha1 >> "$state_dir"/current-commit
# rewrite parents; if none were rewritten, we can fast-forward.
new_parents=
@@ -425,7 +423,7 @@ do_next () {
mark_action_done
pick_one $sha1 ||
die_with_patch $sha1 "Could not apply $sha1... $rest"
- echo "$sha1" > "$dotest"/stopped-sha
+ echo "$sha1" > "$state_dir"/stopped-sha
make_patch $sha1
git rev-parse --verify HEAD > "$amend"
warn "Stopped at $sha1... $rest"
@@ -490,7 +488,7 @@ do_next () {
printf 'Executing: %s\n' "$rest"
# "exec" command doesn't take a sha1 in the todo-list.
# => can't just use $sha1 here.
- git rev-parse --verify HEAD > "$dotest"/stopped-sha
+ git rev-parse --verify HEAD > "$state_dir"/stopped-sha
${SHELL:-@SHELL_PATH@} -c "$rest" # Actual execution
status=$?
if test "$status" -ne 0
@@ -525,19 +523,19 @@ do_next () {
test -s "$todo" && return
comment_for_reflog finish &&
- headname=$(cat "$dotest"/head-name) &&
- oldhead=$(cat "$dotest"/head) &&
- shortonto=$(git rev-parse --short $(cat "$dotest"/onto)) &&
+ head_name=$(cat "$state_dir"/head-name) &&
+ orig_head=$(cat "$state_dir"/head) &&
+ shortonto=$(git rev-parse --short $(cat "$state_dir"/onto)) &&
newhead=$(git rev-parse HEAD) &&
- case $headname in
+ case $head_name in
refs/*)
- message="$GIT_REFLOG_ACTION: $headname onto $shortonto" &&
- git update-ref -m "$message" $headname $newhead $oldhead &&
- git symbolic-ref HEAD $headname
+ message="$GIT_REFLOG_ACTION: $head_name onto $shortonto" &&
+ git update-ref -m "$message" $head_name $newhead $orig_head &&
+ git symbolic-ref HEAD $head_name
;;
esac && {
- test ! -f "$dotest"/verbose ||
- git diff-tree --stat $(cat "$dotest"/head)..HEAD
+ test ! -f "$state_dir"/verbose ||
+ git diff-tree --stat $(cat "$state_dir"/head)..HEAD
} &&
{
test -s "$rewritten_list" &&
@@ -549,9 +547,9 @@ do_next () {
"$GIT_DIR"/hooks/post-rewrite rebase < "$rewritten_list"
true # we don't care if this hook failed
fi &&
- rm -rf "$dotest" &&
+ rm -rf "$state_dir" &&
git gc --auto &&
- warn "Successfully rebased and updated $headname."
+ warn "Successfully rebased and updated $head_name."
exit
}
@@ -602,9 +600,9 @@ skip_unnecessary_picks () {
get_saved_options () {
test -d "$rewritten" && preserve_merges=t
- test -f "$dotest"/strategy && strategy="$(cat "$dotest"/strategy)"
- test -f "$dotest"/verbose && verbose=t
- test -f "$dotest"/rebase-root && rebase_root=t
+ test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
+ test -f "$state_dir"/verbose && verbose=t
+ test -f "$state_dir"/rebase-root && rebase_root=t
}
# Rearrange the todo list that has both "pick sha1 msg" and
@@ -704,7 +702,7 @@ first and then run 'git rebase --continue' again."
}
fi
- record_in_rewritten "$(cat "$dotest"/stopped-sha)"
+ record_in_rewritten "$(cat "$state_dir"/stopped-sha)"
require_clean_work_tree "rebase"
do_rest
@@ -715,15 +713,15 @@ abort)
git rerere clear
- headname=$(cat "$dotest"/head-name)
- head=$(cat "$dotest"/head)
- case $headname in
+ head_name=$(cat "$state_dir"/head-name)
+ orig_head=$(cat "$state_dir"/head)
+ case $head_name in
refs/*)
- git symbolic-ref HEAD $headname
+ git symbolic-ref HEAD $head_name
;;
esac &&
- output git reset --hard $head &&
- rm -rf "$dotest"
+ output git reset --hard $orig_head &&
+ rm -rf "$state_dir"
exit
;;
skip)
@@ -747,28 +745,28 @@ then
die "Could not checkout $switch_to"
fi
-head=$(git rev-parse --verify HEAD) || die "No HEAD?"
-mkdir "$dotest" || die "Could not create temporary $dotest"
+orig_head=$(git rev-parse --verify HEAD) || die "No HEAD?"
+mkdir "$state_dir" || die "Could not create temporary $state_dir"
-: > "$dotest"/interactive || die "Could not mark as interactive"
-echo "$head_name" > "$dotest"/head-name
+: > "$state_dir"/interactive || die "Could not mark as interactive"
+echo "$head_name" > "$state_dir"/head-name
-echo $head > "$dotest"/head
+echo $orig_head > "$state_dir"/head
case "$rebase_root" in
'')
- rm -f "$dotest"/rebase-root ;;
+ rm -f "$state_dir"/rebase-root ;;
*)
- : >"$dotest"/rebase-root ;;
+ : >"$state_dir"/rebase-root ;;
esac
-echo $onto > "$dotest"/onto
-test -z "$strategy" || echo "$strategy" > "$dotest"/strategy
-test t = "$verbose" && : > "$dotest"/verbose
+echo $onto > "$state_dir"/onto
+test -z "$strategy" || echo "$strategy" > "$state_dir"/strategy
+test t = "$verbose" && : > "$state_dir"/verbose
if test t = "$preserve_merges"
then
if test -z "$rebase_root"
then
mkdir "$rewritten" &&
- for c in $(git merge-base --all $head $upstream)
+ for c in $(git merge-base --all $orig_head $upstream)
do
echo $onto > "$rewritten"/$c ||
die "Could not init rewritten commits"
@@ -782,21 +780,21 @@ then
# parents to rewrite and skipping dropped commits would
# prematurely end our probe
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..$orig_head | head -n 1)"
else
merges_option="--no-merges --cherry-pick"
fi
-shorthead=$(git rev-parse --short $head)
+shorthead=$(git rev-parse --short $orig_head)
shortonto=$(git rev-parse --short $onto)
if test -z "$rebase_root"
# this is now equivalent to ! -z "$upstream"
then
shortupstream=$(git rev-parse --short $upstream)
- revisions=$upstream...$head
+ revisions=$upstream...$orig_head
shortrevisions=$shortupstream..$shorthead
else
- revisions=$onto...$head
+ revisions=$onto...$orig_head
shortrevisions=$shorthead
fi
git rev-list $merges_option --pretty=oneline --abbrev-commit \
@@ -837,13 +835,13 @@ then
mkdir "$dropped"
# Save all non-cherry-picked changes
git rev-list $revisions --left-right --cherry-pick | \
- sed -n "s/^>//p" > "$dotest"/not-cherry-picks
+ sed -n "s/^>//p" > "$state_dir"/not-cherry-picks
# Now all commits and note which ones are missing in
# not-cherry-picks and hence being dropped
git rev-list $revisions |
while read rev
do
- if test -f "$rewritten"/$rev -a "$(sane_grep "$rev" "$dotest"/not-cherry-picks)" = ""
+ if test -f "$rewritten"/$rev -a "$(sane_grep "$rev" "$state_dir"/not-cherry-picks)" = ""
then
# Use -f2 because if rev-list is telling us this commit is
# not worthwhile, we don't want to track its multiple heads,
@@ -889,5 +887,5 @@ has_action "$todo" ||
test -d "$rewritten" || test -n "$force_rebase" || skip_unnecessary_picks
output git checkout $onto || die_abort "could not detach HEAD"
-git update-ref ORIG_HEAD $head
+git update-ref ORIG_HEAD $orig_head
do_rest
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 20/31] rebase: show consistent conflict resolution hint
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
When rebase stops due to conflict, interactive rebase currently
displays a different hint to the user than non-interactive rebase
does. Use the same message for both types of rebase.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
Should we include the "mark the corrected paths with 'git add
<paths>'" part?
git-rebase--interactive.sh | 4 +---
1 files changed, 1 insertions(+), 3 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index f94f057..0499f9e 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -81,9 +81,7 @@ amend="$dotest"/amend
rewritten_list="$dotest"/rewritten-list
rewritten_pending="$dotest"/rewritten-pending
-GIT_CHERRY_PICK_HELP="\
-hint: after resolving the conflicts, mark the corrected paths
-hint: with 'git add <paths>' and run 'git rebase --continue'"
+GIT_CHERRY_PICK_HELP="$resolvemsg"
export GIT_CHERRY_PICK_HELP
warn () {
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 17/31] rebase: remove $branch as synonym for $orig_head
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
The variables $branch and $orig_head were used as synonyms. To avoid
confusion, remove $branch. The name 'orig_head' seems more suitable,
since that is the name used when the variable is persisted.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
git-rebase.sh | 19 +++++++++----------
1 files changed, 9 insertions(+), 10 deletions(-)
diff --git a/git-rebase.sh b/git-rebase.sh
index c8a7e4e..ed34906 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -485,10 +485,10 @@ case "$#" in
switch_to="$1"
if git show-ref --verify --quiet -- "refs/heads/$1" &&
- branch=$(git rev-parse -q --verify "refs/heads/$1")
+ orig_head=$(git rev-parse -q --verify "refs/heads/$1")
then
head_name="refs/heads/$1"
- elif branch=$(git rev-parse -q --verify "$1")
+ elif orig_head=$(git rev-parse -q --verify "$1")
then
head_name="detached HEAD"
else
@@ -506,24 +506,23 @@ case "$#" in
head_name="detached HEAD"
branch_name=HEAD ;# detached
fi
- branch=$(git rev-parse --verify "${branch_name}^0") || exit
+ orig_head=$(git rev-parse --verify "${branch_name}^0") || exit
;;
esac
-orig_head=$branch
require_clean_work_tree "rebase" "Please commit or stash them."
-# Now we are rebasing commits $upstream..$branch (or with --root,
-# everything leading up to $branch) on top of $onto
+# Now we are rebasing commits $upstream..$orig_head (or with --root,
+# everything leading up to $orig_head) on top of $onto
# Check if we are already based on $onto with linear history,
# but this should be done only when upstream and onto are the same
# and if this is not an interactive rebase.
-mb=$(git merge-base "$onto" "$branch")
+mb=$(git merge-base "$onto" "$orig_head")
if test "$type" != interactive && test "$upstream" = "$onto" &&
test "$mb" = "$onto" &&
# linear history?
- ! (git rev-list --parents "$onto".."$branch" | sane_grep " .* ") > /dev/null
+ ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
then
if test -z "$force_rebase"
then
@@ -554,11 +553,11 @@ test "$type" = interactive && run_interactive_rebase
# Detach HEAD and reset the tree
say "First, rewinding head to replay your work on top of it..."
git checkout -q "$onto^0" || die "could not detach HEAD"
-git update-ref ORIG_HEAD $branch
+git update-ref ORIG_HEAD $orig_head
# If the $onto is a proper descendant of the tip of the branch, then
# we just fast-forwarded.
-if test "$mb" = "$branch"
+if test "$mb" = "$orig_head"
then
say "Fast-forwarded $branch_name to $onto_name."
move_to_original_branch
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 18/31] rebase: extract merge code to new source file
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
Extract the code for merge-based rebase to git-rebase--merge.sh.
Suggested-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
Changes since v1:
* As suggested by Johannes Sixt, git-rebase--$type is now sourced
instead of executed.
What copyright year? Most of the code is just extracted from
git-rebase.sh, which has copyright year 2005. Does that matter?
Would read_initial_state be a better name than read_basic_state?
.gitignore | 1 +
Makefile | 1 +
git-rebase--merge.sh | 154 +++++++++++++++++++++++++++++++++++++++++++++++
git-rebase.sh | 162 ++++----------------------------------------------
4 files changed, 167 insertions(+), 151 deletions(-)
create mode 100644 git-rebase--merge.sh
diff --git a/.gitignore b/.gitignore
index 3dd6ef7..a8b98b4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -103,6 +103,7 @@
/git-read-tree
/git-rebase
/git-rebase--interactive
+/git-rebase--merge
/git-receive-pack
/git-reflog
/git-relink
diff --git a/Makefile b/Makefile
index 775ee83..f47550f 100644
--- a/Makefile
+++ b/Makefile
@@ -370,6 +370,7 @@ SCRIPT_SH += git-mergetool.sh
SCRIPT_SH += git-pull.sh
SCRIPT_SH += git-quiltimport.sh
SCRIPT_SH += git-rebase--interactive.sh
+SCRIPT_SH += git-rebase--merge.sh
SCRIPT_SH += git-rebase.sh
SCRIPT_SH += git-repack.sh
SCRIPT_SH += git-request-pull.sh
diff --git a/git-rebase--merge.sh b/git-rebase--merge.sh
new file mode 100644
index 0000000..c04ce8a
--- /dev/null
+++ b/git-rebase--merge.sh
@@ -0,0 +1,154 @@
+#!/bin/sh
+#
+# Copyright (c) 2010 Junio C Hamano.
+#
+
+. git-sh-setup
+
+prec=4
+
+read_state () {
+ onto_name=$(cat "$state_dir"/onto_name) &&
+ end=$(cat "$state_dir"/end) &&
+ msgnum=$(cat "$state_dir"/msgnum)
+}
+
+continue_merge () {
+ test -d "$state_dir" || die "$state_dir 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 to use git add?"
+ die "$resolvemsg"
+ fi
+
+ cmt=`cat "$state_dir/current"`
+ if ! git diff-index --quiet --ignore-submodules HEAD --
+ then
+ if ! git commit --no-verify -C "$cmt"
+ then
+ echo "Commit failed, please do not call \"git commit\""
+ echo "directly, but instead do one of the following: "
+ die "$resolvemsg"
+ fi
+ if test -z "$GIT_QUIET"
+ then
+ printf "Committed: %0${prec}d " $msgnum
+ fi
+ echo "$cmt $(git rev-parse HEAD^0)" >> "$state_dir/rewritten"
+ else
+ if test -z "$GIT_QUIET"
+ then
+ printf "Already applied: %0${prec}d " $msgnum
+ fi
+ fi
+ test -z "$GIT_QUIET" &&
+ GIT_PAGER='' git log --format=%s -1 "$cmt"
+
+ # onto the next patch:
+ msgnum=$(($msgnum + 1))
+ echo "$msgnum" >"$state_dir/msgnum"
+}
+
+call_merge () {
+ cmt="$(cat "$state_dir/cmt.$1")"
+ echo "$cmt" > "$state_dir/current"
+ hd=$(git rev-parse --verify HEAD)
+ cmt_name=$(git symbolic-ref HEAD 2> /dev/null || echo HEAD)
+ msgnum=$(cat "$state_dir/msgnum")
+ eval GITHEAD_$cmt='"${cmt_name##refs/heads/}~$(($end - $msgnum))"'
+ eval GITHEAD_$hd='$onto_name'
+ export GITHEAD_$cmt GITHEAD_$hd
+ if test -n "$GIT_QUIET"
+ then
+ GIT_MERGE_VERBOSITY=1 && export GIT_MERGE_VERBOSITY
+ fi
+ test -z "$strategy" && strategy=recursive
+ eval 'git-merge-$strategy' $strategy_opts '"$cmt^" -- "$hd" "$cmt"'
+ rv=$?
+ case "$rv" in
+ 0)
+ unset GITHEAD_$cmt GITHEAD_$hd
+ return
+ ;;
+ 1)
+ git rerere $allow_rerere_autoupdate
+ die "$resolvemsg"
+ ;;
+ 2)
+ echo "Strategy: $rv $strategy failed, try another" 1>&2
+ die "$resolvemsg"
+ ;;
+ *)
+ die "Unknown exit code ($rv) from command:" \
+ "git-merge-$strategy $cmt^ -- HEAD $cmt"
+ ;;
+ esac
+}
+
+finish_rb_merge () {
+ move_to_original_branch
+ git notes copy --for-rewrite=rebase < "$state_dir"/rewritten
+ if test -x "$GIT_DIR"/hooks/post-rewrite &&
+ test -s "$state_dir"/rewritten; then
+ "$GIT_DIR"/hooks/post-rewrite rebase < "$state_dir"/rewritten
+ fi
+ rm -r "$state_dir"
+ say All done.
+}
+
+case "$action" in
+continue)
+ read_state
+ continue_merge
+ while test "$msgnum" -le "$end"
+ do
+ call_merge "$msgnum"
+ continue_merge
+ done
+ finish_rb_merge
+ exit
+ ;;
+skip)
+ read_state
+ git rerere clear
+ msgnum=$(($msgnum + 1))
+ while test "$msgnum" -le "$end"
+ do
+ call_merge "$msgnum"
+ continue_merge
+ done
+ finish_rb_merge
+ exit
+ ;;
+esac
+
+mkdir -p "$state_dir"
+echo "$onto_name" > "$state_dir/onto_name"
+echo "$head_name" > "$state_dir/head-name"
+echo "$onto" > "$state_dir/onto"
+echo "$orig_head" > "$state_dir/orig-head"
+echo "$GIT_QUIET" > "$state_dir/quiet"
+
+msgnum=0
+for cmt in `git rev-list --reverse --no-merges "$revisions"`
+do
+ msgnum=$(($msgnum + 1))
+ echo "$cmt" > "$state_dir/cmt.$msgnum"
+done
+
+echo 1 >"$state_dir/msgnum"
+echo $msgnum >"$state_dir/end"
+
+end=$msgnum
+msgnum=1
+
+while test "$msgnum" -le "$end"
+do
+ call_merge "$msgnum"
+ continue_merge
+done
+
+finish_rb_merge
diff --git a/git-rebase.sh b/git-rebase.sh
index ed34906..44e169f 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -48,7 +48,6 @@ strategy_opts=
do_merge=
merge_dir="$GIT_DIR"/rebase-merge
apply_dir="$GIT_DIR"/rebase-apply
-prec=4
verbose=
diffstat=
test "$(git config --bool rebase.stat)" = true && diffstat=t
@@ -68,94 +67,13 @@ preserve_merges=
autosquash=
test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
-read_state () {
- if test "$type" = merge
- then
- onto_name=$(cat "$state_dir"/onto_name) &&
- end=$(cat "$state_dir"/end) &&
- msgnum=$(cat "$state_dir"/msgnum)
- fi &&
+read_basic_state () {
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)
}
-continue_merge () {
- test -d "$merge_dir" || die "$merge_dir 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 to use git add?"
- die "$resolvemsg"
- fi
-
- cmt=`cat "$merge_dir/current"`
- if ! git diff-index --quiet --ignore-submodules HEAD --
- then
- if ! git commit --no-verify -C "$cmt"
- then
- echo "Commit failed, please do not call \"git commit\""
- echo "directly, but instead do one of the following: "
- die "$resolvemsg"
- fi
- if test -z "$GIT_QUIET"
- then
- printf "Committed: %0${prec}d " $msgnum
- fi
- echo "$cmt $(git rev-parse HEAD^0)" >> "$merge_dir/rewritten"
- else
- if test -z "$GIT_QUIET"
- then
- printf "Already applied: %0${prec}d " $msgnum
- fi
- fi
- test -z "$GIT_QUIET" &&
- GIT_PAGER='' git log --format=%s -1 "$cmt"
-
- # onto the next patch:
- msgnum=$(($msgnum + 1))
- echo "$msgnum" >"$merge_dir/msgnum"
-}
-
-call_merge () {
- cmt="$(cat "$merge_dir/cmt.$1")"
- echo "$cmt" > "$merge_dir/current"
- hd=$(git rev-parse --verify HEAD)
- cmt_name=$(git symbolic-ref HEAD 2> /dev/null || echo HEAD)
- msgnum=$(cat "$merge_dir/msgnum")
- eval GITHEAD_$cmt='"${cmt_name##refs/heads/}~$(($end - $msgnum))"'
- eval GITHEAD_$hd='$onto_name'
- export GITHEAD_$cmt GITHEAD_$hd
- if test -n "$GIT_QUIET"
- then
- GIT_MERGE_VERBOSITY=1 && export GIT_MERGE_VERBOSITY
- fi
- test -z "$strategy" && strategy=recursive
- eval 'git-merge-$strategy' $strategy_opts '"$cmt^" -- "$hd" "$cmt"'
- rv=$?
- case "$rv" in
- 0)
- unset GITHEAD_$cmt GITHEAD_$hd
- return
- ;;
- 1)
- git rerere $allow_rerere_autoupdate
- die "$resolvemsg"
- ;;
- 2)
- echo "Strategy: $rv $strategy failed, try another" 1>&2
- die "$resolvemsg"
- ;;
- *)
- die "Unknown exit code ($rv) from command:" \
- "git-merge-$strategy $cmt^ -- HEAD $cmt"
- ;;
- esac
-}
-
move_to_original_branch () {
case "$head_name" in
refs/*)
@@ -168,23 +86,12 @@ move_to_original_branch () {
esac
}
-finish_rb_merge () {
- move_to_original_branch
- git notes copy --for-rewrite=rebase < "$merge_dir"/rewritten
- if test -x "$GIT_DIR"/hooks/post-rewrite &&
- test -s "$merge_dir"/rewritten; then
- "$GIT_DIR"/hooks/post-rewrite rebase < "$merge_dir"/rewritten
- fi
- rm -r "$merge_dir"
- say All done.
-}
-
-run_interactive_rebase () {
+run_specific_rebase () {
if [ "$interactive_rebase" = implied ]; then
GIT_EDITOR=:
export GIT_EDITOR
fi
- . git-rebase--interactive
+ test "$type" != am && . git-rebase--$type
}
run_pre_rebase_hook () {
@@ -341,7 +248,7 @@ test $# -gt 2 && usage
if test -n "$action"
then
test -z "$in_progress" && die "No rebase in progress?"
- test "$type" = interactive && run_interactive_rebase
+ test "$type" = interactive && run_specific_rebase
fi
case "$action" in
@@ -352,44 +259,23 @@ continue)
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
+ read_basic_state
+ run_specific_rebase
git am --resolved --3way --resolvemsg="$resolvemsg" &&
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
+ read_basic_state
+ run_specific_rebase
git am -3 --skip --resolvemsg="$resolvemsg" &&
move_to_original_branch
exit
;;
abort)
git rerere clear
- read_state
+ read_basic_state
case "$head_name" in
refs/*)
git symbolic-ref HEAD $head_name ||
@@ -548,7 +434,7 @@ then
GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
fi
-test "$type" = interactive && run_interactive_rebase
+test "$type" = interactive && run_specific_rebase
# Detach HEAD and reset the tree
say "First, rewinding head to replay your work on top of it..."
@@ -590,30 +476,4 @@ fi
# start doing a rebase with git-merge
# this is rename-aware if the recursive (default) strategy is used
-mkdir -p "$merge_dir"
-echo "$onto_name" > "$merge_dir/onto_name"
-echo "$head_name" > "$merge_dir/head-name"
-echo "$onto" > "$merge_dir/onto"
-echo "$orig_head" > "$merge_dir/orig-head"
-echo "$GIT_QUIET" > "$merge_dir/quiet"
-
-msgnum=0
-for cmt in `git rev-list --reverse --no-merges "$revisions"`
-do
- msgnum=$(($msgnum + 1))
- echo "$cmt" > "$merge_dir/cmt.$msgnum"
-done
-
-echo 1 >"$merge_dir/msgnum"
-echo $msgnum >"$merge_dir/end"
-
-end=$msgnum
-msgnum=1
-
-while test "$msgnum" -le "$end"
-do
- call_merge "$msgnum"
- continue_merge
-done
-
-finish_rb_merge
+run_specific_rebase
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 14/31] rebase: factor out clean work tree check
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
Remove the check for clean work tree from git-rebase--interactive.sh and
rely on the check in git-rebase.sh.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
git-rebase--interactive.sh | 2 --
git-rebase.sh | 4 ++--
2 files changed, 2 insertions(+), 4 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index fbe12a6..1ba98a2 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -753,8 +753,6 @@ esac
git var GIT_COMMITTER_IDENT >/dev/null ||
die "You need to set your committer info first"
-require_clean_work_tree "rebase" "Please commit or stash them."
-
run_pre_rebase_hook "$upstream_arg" "$@"
comment_for_reflog start
diff --git a/git-rebase.sh b/git-rebase.sh
index 0f5f5fb..265f01d 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -511,10 +511,10 @@ case "$#" in
esac
orig_head=$branch
-test "$type" = interactive && run_interactive_rebase "$@"
-
require_clean_work_tree "rebase" "Please commit or stash them."
+test "$type" = interactive && run_interactive_rebase "$@"
+
# Now we are rebasing commits $upstream..$branch (or with --root,
# everything leading up to $branch) on top of $onto
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 15/31] rebase: factor out call to pre-rebase hook
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
Remove the call to the pre-rebase hook from
git-rebase--interactive.sh and rely on the call in
git-rebase.sh.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
git-rebase--interactive.sh | 14 --------------
git-rebase.sh | 12 +++++++-----
2 files changed, 7 insertions(+), 19 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index 1ba98a2..f94f057 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -109,18 +109,6 @@ commit_message () {
git cat-file commit "$1" | sed "1,/^$/d"
}
-run_pre_rebase_hook () {
- if test -z "$ok_to_skip_pre_rebase" &&
- 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
-}
-
-
orig_reflog_action="$GIT_REFLOG_ACTION"
comment_for_reflog () {
@@ -753,8 +741,6 @@ esac
git var GIT_COMMITTER_IDENT >/dev/null ||
die "You need to set your committer info first"
-run_pre_rebase_hook "$upstream_arg" "$@"
-
comment_for_reflog start
if test ! -z "$switch_to"
diff --git a/git-rebase.sh b/git-rebase.sh
index 265f01d..87d7fde 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -184,7 +184,7 @@ run_interactive_rebase () {
GIT_EDITOR=:
export GIT_EDITOR
fi
- . git-rebase--interactive "$@"
+ . git-rebase--interactive
}
run_pre_rebase_hook () {
@@ -513,15 +513,15 @@ orig_head=$branch
require_clean_work_tree "rebase" "Please commit or stash them."
-test "$type" = interactive && run_interactive_rebase "$@"
-
# Now we are rebasing commits $upstream..$branch (or with --root,
# everything leading up to $branch) on top of $onto
# Check if we are already based on $onto with linear history,
-# but this should be done only when upstream and onto are the same.
+# but this should be done only when upstream and onto are the same
+# and if this is not an interactive rebase.
mb=$(git merge-base "$onto" "$branch")
-if test "$upstream" = "$onto" && test "$mb" = "$onto" &&
+if test "$type" != interactive && test "$upstream" = "$onto" &&
+ test "$mb" = "$onto" &&
# linear history?
! (git rev-list --parents "$onto".."$branch" | sane_grep " .* ") > /dev/null
then
@@ -539,6 +539,8 @@ fi
# If a hook exists, give it a chance to interrupt
run_pre_rebase_hook "$upstream_arg" "$@"
+test "$type" = interactive && run_interactive_rebase
+
# Detach HEAD and reset the tree
say "First, rewinding head to replay your work on top of it..."
git checkout -q "$onto^0" || die "could not detach HEAD"
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 12/31] rebase: reorder validation steps
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
Reorder validation steps in preparation for the validation to be factored
out from git-rebase--interactive.sh into git-rebase.sh.
The main functional difference is that the pre-rebase hook will no longer
be run if the work tree is dirty.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
git-rebase--interactive.sh | 4 ++--
git-rebase.sh | 10 +++++-----
2 files changed, 7 insertions(+), 7 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index 4f4fb29..0f04f36 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -792,12 +792,12 @@ else
test -z "$onto" &&
die "You must specify --onto when using --root"
fi
+require_clean_work_tree "rebase" "Please commit or stash them."
+
run_pre_rebase_hook "$upstream_arg" "$@"
comment_for_reflog start
-require_clean_work_tree "rebase" "Please commit or stash them."
-
if test ! -z "$1"
then
output git checkout "$1" -- ||
diff --git a/git-rebase.sh b/git-rebase.sh
index aa1bcaf..4a83d10 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -433,8 +433,6 @@ fi
test "$type" = interactive && run_interactive_rebase "$@"
-require_clean_work_tree "rebase" "Please commit or stash them."
-
if test -z "$rebase_root"
then
# The upstream head must be given. Make sure it is valid.
@@ -476,9 +474,6 @@ case "$onto_name" in
;;
esac
-# If a hook exists, give it a chance to interrupt
-run_pre_rebase_hook "$upstream_arg" "$@"
-
# 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
@@ -517,6 +512,8 @@ case "$#" in
esac
orig_head=$branch
+require_clean_work_tree "rebase" "Please commit or stash them."
+
# Now we are rebasing commits $upstream..$branch (or with --root,
# everything leading up to $branch) on top of $onto
@@ -538,6 +535,9 @@ then
fi
fi
+# If a hook exists, give it a chance to interrupt
+run_pre_rebase_hook "$upstream_arg" "$@"
+
# Detach HEAD and reset the tree
say "First, rewinding head to replay your work on top of it..."
git checkout -q "$onto^0" || die "could not detach HEAD"
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 13/31] rebase: factor out reference parsing
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
Remove the parsing and validation of references (onto, upstream, branch)
from git-rebase--interactive.sh and rely on the information exported from
git-rebase.sh.
By using the parsing of the --onto parameter in git-rebase.sh, this
improves the error message when the parameter is invalid.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
Should the check for set GIT_COMMITTER_IDENT be done for
non-interactive rebase as well or does it only make sense for
interactive rebase?
git-rebase--interactive.sh | 48 +++----------------------------------------
git-rebase.sh | 9 ++++---
2 files changed, 9 insertions(+), 48 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index 0f04f36..fbe12a6 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -682,25 +682,6 @@ rearrange_squash () {
rm -f "$1.sq" "$1.rearranged"
}
-LF='
-'
-parse_onto () {
- case "$1" in
- *...*)
- if left=${1%...*} right=${1#*...} &&
- onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
- then
- case "$onto" in
- ?*"$LF"?* | '')
- exit 1 ;;
- esac
- echo "$onto"
- exit 0
- fi
- esac
- git rev-parse --verify "$1^0"
-}
-
case "$action" in
continue)
get_saved_options
@@ -769,47 +750,26 @@ skip)
;;
esac
-if test -n "$onto"
-then
- onto=$(parse_onto "$onto") || die "Does not point to a valid commit: $1"
-fi
-
-test -z "$rebase_root" -a $# -ge 1 -a $# -le 2 ||
-test ! -z "$rebase_root" -a $# -le 1 || usage
-
git var GIT_COMMITTER_IDENT >/dev/null ||
die "You need to set your committer info first"
-if test -z "$rebase_root"
-then
- upstream_arg="$1"
- upstream=$(git rev-parse --verify "$1") || die "Invalid base"
- test -z "$onto" && onto=$upstream
- shift
-else
- upstream=
- upstream_arg=--root
- test -z "$onto" &&
- die "You must specify --onto when using --root"
-fi
require_clean_work_tree "rebase" "Please commit or stash them."
run_pre_rebase_hook "$upstream_arg" "$@"
comment_for_reflog start
-if test ! -z "$1"
+if test ! -z "$switch_to"
then
- output git checkout "$1" -- ||
- die "Could not checkout $1"
+ output git checkout "$switch_to" -- ||
+ die "Could not checkout $switch_to"
fi
head=$(git rev-parse --verify HEAD) || die "No HEAD?"
mkdir "$dotest" || die "Could not create temporary $dotest"
: > "$dotest"/interactive || die "Could not mark as interactive"
-git symbolic-ref HEAD > "$dotest"/head-name 2> /dev/null ||
- echo "detached HEAD" > "$dotest"/head-name
+echo "$head_name" > "$dotest"/head-name
echo $head > "$dotest"/head
case "$rebase_root" in
diff --git a/git-rebase.sh b/git-rebase.sh
index 4a83d10..0f5f5fb 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -431,8 +431,6 @@ else
state_dir="$apply_dir"
fi
-test "$type" = interactive && run_interactive_rebase "$@"
-
if test -z "$rebase_root"
then
# The upstream head must be given. Make sure it is valid.
@@ -443,7 +441,7 @@ then
unset root_flag
upstream_arg="$upstream_name"
else
- test -z "$onto" && die "--root must be used with --onto"
+ test -z "$onto" && die "You must specify --onto when using --root"
unset upstream_name
unset upstream
root_flag="--root"
@@ -470,7 +468,8 @@ case "$onto_name" in
fi
;;
*)
- onto=$(git rev-parse --verify "${onto_name}^0") || exit
+ onto=$(git rev-parse --verify "${onto_name}^0") ||
+ die "Does not point to a valid commit: $1"
;;
esac
@@ -512,6 +511,8 @@ case "$#" in
esac
orig_head=$branch
+test "$type" = interactive && run_interactive_rebase "$@"
+
require_clean_work_tree "rebase" "Please commit or stash them."
# Now we are rebasing commits $upstream..$branch (or with --root,
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 07/31] rebase: stricter check of standalone sub command
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
The sub commands '--continue', '--skip' or '--abort' may only be used
standalone according to the documentation. Other options following the
sub command are currently not accepted, but options preceeding them
are. For example, 'git rebase --continue -v' is not accepted, while
'git rebase -v --continue' is. Tighten up the check and allow no other
options when one of these sub commands are used.
Only check that it is standalone for non-interactive rebase for
now. Once the command line processing for interactive rebase has been
replaced by the command line processing in git-rebase.sh, this check
will also apply to interactive rebase.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
Is this too simplistic? Do we forsee that we want to support passing
options when resuming a rebase? Is it better to check for each other
option that it is not passed (i.e. no '-v', no '-s' etc.)?
Might some users be depending on the current behavior, even though it
is undocumented?
git-rebase.sh | 4 ++--
t/t3403-rebase-skip.sh | 5 +++++
t/t3407-rebase-abort.sh | 10 ++++++++++
t/t3418-rebase-continue.sh | 5 +++++
4 files changed, 22 insertions(+), 2 deletions(-)
diff --git a/git-rebase.sh b/git-rebase.sh
index e3fd001..d689aad 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -229,6 +229,7 @@ then
fi
test -n "$type" && in_progress=t
+total_argc=$#
while test $# != 0
do
case "$1" in
@@ -239,9 +240,8 @@ do
OK_TO_SKIP_PRE_REBASE=
;;
--continue|--skip|--abort)
+ test $total_argc -eq 1 || usage
action=${1##--}
- shift
- break
;;
--onto)
test 2 -le "$#" || usage
diff --git a/t/t3403-rebase-skip.sh b/t/t3403-rebase-skip.sh
index 64446e3..826500b 100755
--- a/t/t3403-rebase-skip.sh
+++ b/t/t3403-rebase-skip.sh
@@ -35,6 +35,11 @@ test_expect_success 'rebase with git am -3 (default)' '
test_must_fail git rebase master
'
+test_expect_success 'rebase --skip can not be used with other options' '
+ test_must_fail git rebase -v --skip &&
+ test_must_fail git rebase --skip -v
+'
+
test_expect_success 'rebase --skip with am -3' '
git rebase --skip
'
diff --git a/t/t3407-rebase-abort.sh b/t/t3407-rebase-abort.sh
index e573dc8..a6a6c40 100755
--- a/t/t3407-rebase-abort.sh
+++ b/t/t3407-rebase-abort.sh
@@ -84,6 +84,16 @@ testrebase() {
test_cmp reflog_before reflog_after &&
rm reflog_before reflog_after
'
+
+ test_expect_success 'rebase --abort can not be used with other options' '
+ cd "$work_dir" &&
+ # Clean up the state from the previous one
+ git reset --hard pre-rebase &&
+ test_must_fail git rebase$type master &&
+ test_must_fail git rebase -v --abort &&
+ test_must_fail git rebase --abort -v &&
+ git rebase --abort
+ '
}
testrebase "" .git/rebase-apply
diff --git a/t/t3418-rebase-continue.sh b/t/t3418-rebase-continue.sh
index 3b0d273..1d90191 100755
--- a/t/t3418-rebase-continue.sh
+++ b/t/t3418-rebase-continue.sh
@@ -40,4 +40,9 @@ test_expect_success 'non-interactive rebase --continue works with touched file'
git rebase --continue
'
+test_expect_success 'rebase --continue can not be used with other options' '
+ test_must_fail git rebase -v --continue &&
+ test_must_fail git rebase --continue -v
+'
+
test_done
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 02/31] rebase: refactor reading of state
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
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>
---
git-rebase.sh | 53 +++++++++++++++++++++++------------------------------
1 files changed, 23 insertions(+), 30 deletions(-)
diff --git a/git-rebase.sh b/git-rebase.sh
index 72696bf..63b5683 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -57,6 +57,22 @@ rebase_root=
force_rebase=
allow_rerere_autoupdate=
+read_state () {
+ if test -d "$merge_dir"
+ then
+ state_dir="$merge_dir"
+ prev_head=$(cat "$merge_dir"/prev_head) &&
+ end=$(cat "$merge_dir"/end) &&
+ msgnum=$(cat "$merge_dir"/msgnum)
+ else
+ state_dir="$apply_dir"
+ 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)
+}
+
continue_merge () {
test -n "$prev_head" || die "prev_head must be defined"
test -d "$merge_dir" || die "$merge_dir directory does not exist"
@@ -138,10 +154,6 @@ call_merge () {
}
move_to_original_branch () {
- test -z "$head_name" &&
- head_name="$(cat "$merge_dir"/head-name)" &&
- onto="$(cat "$merge_dir"/onto)" &&
- orig_head="$(cat "$merge_dir"/orig-head)"
case "$head_name" in
refs/*)
message="rebase finished: $head_name onto $onto"
@@ -220,13 +232,9 @@ do
echo "mark them as resolved using git add"
exit 1
}
+ read_state
if test -d "$merge_dir"
then
- prev_head=$(cat "$merge_dir/prev_head")
- end=$(cat "$merge_dir/end")
- msgnum=$(cat "$merge_dir/msgnum")
- onto=$(cat "$merge_dir/onto")
- GIT_QUIET=$(cat "$merge_dir/quiet")
continue_merge
while test "$msgnum" -le "$end"
do
@@ -236,10 +244,6 @@ do
finish_rb_merge
exit
fi
- head_name=$(cat "$apply_dir"/head-name) &&
- onto=$(cat "$apply_dir"/onto) &&
- orig_head=$(cat "$apply_dir"/orig-head) &&
- GIT_QUIET=$(cat "$apply_dir"/quiet)
git am --resolved --3way --resolvemsg="$RESOLVEMSG" &&
move_to_original_branch
exit
@@ -249,15 +253,11 @@ do
die "No rebase in progress?"
git reset --hard HEAD || exit $?
+ read_state
if test -d "$merge_dir"
then
git rerere clear
- prev_head=$(cat "$merge_dir/prev_head")
- end=$(cat "$merge_dir/end")
- msgnum=$(cat "$merge_dir/msgnum")
msgnum=$(($msgnum + 1))
- onto=$(cat "$merge_dir/onto")
- GIT_QUIET=$(cat "$merge_dir/quiet")
while test "$msgnum" -le "$end"
do
call_merge "$msgnum"
@@ -266,10 +266,6 @@ do
finish_rb_merge
exit
fi
- head_name=$(cat "$apply_dir"/head-name) &&
- onto=$(cat "$apply_dir"/onto) &&
- orig_head=$(cat "$apply_dir"/orig-head) &&
- GIT_QUIET=$(cat "$apply_dir"/quiet)
git am -3 --skip --resolvemsg="$RESOLVEMSG" &&
move_to_original_branch
exit
@@ -279,18 +275,15 @@ do
die "No rebase in progress?"
git rerere clear
-
- test -d "$merge_dir" || merge_dir="$apply_dir"
-
- head_name="$(cat "$merge_dir"/head-name)" &&
+ 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 $(cat "$merge_dir/orig-head")
- rm -r "$merge_dir"
+ git reset --hard $orig_head
+ rm -r "$state_dir"
exit
;;
--onto)
@@ -574,12 +567,12 @@ fi
# this is rename-aware if the recursive (default) strategy is used
mkdir -p "$merge_dir"
-echo "$onto" > "$merge_dir/onto"
echo "$onto_name" > "$merge_dir/onto_name"
prev_head=$orig_head
echo "$prev_head" > "$merge_dir/prev_head"
-echo "$orig_head" > "$merge_dir/orig-head"
echo "$head_name" > "$merge_dir/head-name"
+echo "$onto" > "$merge_dir/onto"
+echo "$orig_head" > "$merge_dir/orig-head"
echo "$GIT_QUIET" > "$merge_dir/quiet"
msgnum=0
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 11/31] rebase -i: remove now unnecessary directory checks
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
Remove directory checks from git-rebase--interactive.sh that are done in
git-rebase.sh.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
Squash with previous?
git-rebase--interactive.sh | 6 ------
1 files changed, 0 insertions(+), 6 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index 9c43c60..4f4fb29 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -706,8 +706,6 @@ continue)
get_saved_options
comment_for_reflog continue
- test -d "$dotest" || die "No interactive rebase running"
-
# Sanity check
git rev-parse --verify HEAD >/dev/null ||
die "Cannot read HEAD"
@@ -749,7 +747,6 @@ abort)
comment_for_reflog abort
git rerere clear
- test -d "$dotest" || die "No interactive rebase running"
headname=$(cat "$dotest"/head-name)
head=$(cat "$dotest"/head)
@@ -767,7 +764,6 @@ skip)
comment_for_reflog skip
git rerere clear
- test -d "$dotest" || die "No interactive rebase running"
output git reset --hard && do_rest
;;
@@ -780,8 +776,6 @@ fi
test -z "$rebase_root" -a $# -ge 1 -a $# -le 2 ||
test ! -z "$rebase_root" -a $# -le 1 || usage
-test -d "$dotest" &&
- die "Interactive rebase already started"
git var GIT_COMMITTER_IDENT >/dev/null ||
die "You need to set your committer info first"
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 09/31] rebase: align variable content
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
Make sure to interpret variables with the same name in the same way in
git-rebase.sh and git-rebase--interactive.sh. This will make it easier
to factor out code from git-rebase.sh to git-rebase--interactive and
export the variables.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
git-rebase--interactive.sh | 16 +++++++++++-----
git-rebase.sh | 4 +++-
2 files changed, 14 insertions(+), 6 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index 2fa348b..8b0d7b0 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -339,7 +339,8 @@ pick_one_preserving_merges () {
# No point in merging the first parent, that's HEAD
new_parents=${new_parents# $first_parent}
if ! do_with_author output \
- git merge $strategy -m "$msg_content" $new_parents
+ git merge ${strategy:+-s $strategy} -m \
+ "$msg_content" $new_parents
then
printf "%s\n" "$msg_content" > "$GIT_DIR"/MERGE_MSG
die_with_patch $sha1 "Error redoing merge $sha1"
@@ -827,11 +828,11 @@ first and then run 'git rebase --continue' again."
-s)
case "$#,$1" in
*,*=*)
- strategy="-s "$(expr "z$1" : 'z-[^=]*=\(.*\)') ;;
+ strategy=$(expr "z$1" : 'z-[^=]*=\(.*\)') ;;
1,*)
usage ;;
*)
- strategy="-s $2"
+ strategy="$2"
shift ;;
esac
;;
@@ -860,9 +861,9 @@ first and then run 'git rebase --continue' again."
autosquash=
;;
--onto)
+ test 2 -le "$#" || usage
+ onto="$2"
shift
- onto=$(parse_onto "$1") ||
- die "Does not point to a valid commit: $1"
;;
--)
shift
@@ -872,6 +873,11 @@ first and then run 'git rebase --continue' again."
shift
done
+if test -n "$onto"
+then
+ onto=$(parse_onto "$onto") || die "Does not point to a valid commit: $1"
+fi
+
test -z "$rebase_root" -a $# -ge 1 -a $# -le 2 ||
test ! -z "$rebase_root" -a $# -le 1 || usage
test -d "$dotest" &&
diff --git a/git-rebase.sh b/git-rebase.sh
index dfde62f..3eac5a4 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -43,7 +43,7 @@ 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\".
"
unset onto
-strategy=recursive
+strategy=
strategy_opts=
do_merge=
merge_dir="$GIT_DIR"/rebase-merge
@@ -130,6 +130,7 @@ call_merge () {
then
GIT_MERGE_VERBOSITY=1 && export GIT_MERGE_VERBOSITY
fi
+ test -z "$strategy" && strategy=recursive
eval 'git-merge-$strategy' $strategy_opts '"$cmt^" -- "$hd" "$cmt"'
rv=$?
case "$rv" in
@@ -267,6 +268,7 @@ do
esac
strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--$newopt")"
do_merge=t
+ test -z "$strategy" && strategy=recursive
;;
-s=*|--s=*|--st=*|--str=*|--stra=*|--strat=*|--strate=*|\
--strateg=*|--strategy=*|\
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 08/31] rebase: align variable names
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
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>
---
Changes since v1:
* As suggested by Thomas, downcase *all* variables, so that the end
result looks consistent.
git-rebase--interactive.sh | 480 ++++++++++++++++++++++----------------------
git-rebase.sh | 32 ++--
2 files changed, 256 insertions(+), 256 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index 824f4f3..2fa348b 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -36,22 +36,22 @@ autosquash move commits that begin with squash!/fixup! under -i
. git-sh-setup
require_work_tree
-DOTEST="$GIT_DIR/rebase-merge"
+dotest="$GIT_DIR/rebase-merge"
# The file containing rebase commands, comments, and empty lines.
# 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
-# file and written to the tail of $DONE.
-TODO="$DOTEST"/git-rebase-todo
+# file and written to the tail of $done.
+todo="$dotest"/git-rebase-todo
# The rebase command lines that have already been processed. A line
# is moved here when it is first handled, before any associated user
# actions.
-DONE="$DOTEST"/done
+done="$dotest"/done
# The commit message that is planned to be used for any changes that
# 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
# 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.
#
# The first line of the file is of the form
-# # This is a combination of $COUNT commits.
-# where $COUNT is the number of commits whose messages have been
+# # This is a combination of $count commits.
+# where $count is the number of commits whose messages have been
# written to the file so far (including the initial "pick" commit).
# Each time that a commit message is processed, this line is read and
# updated. It is deleted just before the combined commit is made.
-SQUASH_MSG="$DOTEST"/message-squash
+squash_msg="$dotest"/message-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
# original "pick" commit. (If the series ends without a "squash"
# command, then this can be used as the commit message of the combined
# 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
-# commit that is reachable by at least one merge base of $HEAD and
-# $UPSTREAM. They are not necessarily rewritten, but their children
+# $rewritten is the name of a directory containing files for each
+# commit that is reachable by at least one merge base of $head and
+# $upstream. They are not necessarily rewritten, but their children
# might be. This ensures that commits on merged, but otherwise
# unrelated side branches are left alone. (Think "X" in the man page's
# 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
# GIT_AUTHOR_DATE that will be used for the commit that is currently
# being rebased.
-AUTHOR_SCRIPT="$DOTEST"/author-script
+author_script="$dotest"/author-script
# When an "edit" rebase command is being processed, the SHA1 of the
# 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
# commit is still the commit to be edited. When any other rebase
# 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
# their new sha1s. The rewritten-pending list keeps the sha1s of
# commits that have been processed, but not committed yet,
# e.g. because they are waiting for a 'squash' command.
-REWRITTEN_LIST="$DOTEST"/rewritten-list
-REWRITTEN_PENDING="$DOTEST"/rewritten-pending
-
-PRESERVE_MERGES=
-STRATEGY=
-ONTO=
-VERBOSE=
-OK_TO_SKIP_PRE_REBASE=
-REBASE_ROOT=
-AUTOSQUASH=
-test "$(git config --bool rebase.autosquash)" = "true" && AUTOSQUASH=t
-NEVER_FF=
+rewritten_list="$dotest"/rewritten-list
+rewritten_pending="$dotest"/rewritten-pending
+
+preserve_merges=
+strategy=
+onto=
+verbose=
+ok_to_skip_pre_rebase=
+rebase_root=
+autosquash=
+test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
+force_rebase=
GIT_CHERRY_PICK_HELP="\
hint: after resolving the conflicts, mark the corrected paths
@@ -125,7 +125,7 @@ warn () {
}
output () {
- case "$VERBOSE" in
+ case "$verbose" in
'')
output=$("$@" 2>&1 )
status=$?
@@ -144,7 +144,7 @@ commit_message () {
}
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"
then
"$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 () {
- case "$ORIG_REFLOG_ACTION" in
+ case "$orig_reflog_action" in
''|rebase*)
GIT_REFLOG_ACTION="rebase -i ($1)"
export GIT_REFLOG_ACTION
@@ -168,16 +168,16 @@ comment_for_reflog () {
last_count=
mark_action_done () {
- sed -e 1q < "$TODO" >> "$DONE"
- sed -e 1d < "$TODO" >> "$TODO".new
- mv -f "$TODO".new "$TODO"
- count=$(sane_grep -c '^[^#]' < "$DONE")
- total=$(($count+$(sane_grep -c '^[^#]' < "$TODO")))
- if test "$last_count" != "$count"
+ sed -e 1q < "$todo" >> "$done"
+ sed -e 1d < "$todo" >> "$todo".new
+ mv -f "$todo".new "$todo"
+ new_count=$(sane_grep -c '^[^#]' < "$done")
+ total=$(($new_count+$(sane_grep -c '^[^#]' < "$todo")))
+ if test "$last_count" != "$new_count"
then
- last_count=$count
- printf "Rebasing (%d/%d)\r" $count $total
- test -z "$VERBOSE" || echo
+ last_count=$new_count
+ printf "Rebasing (%d/%d)\r" $new_count $total
+ test -z "$verbose" || echo
fi
}
@@ -193,22 +193,22 @@ make_patch () {
*)
echo "Root commit"
;;
- esac > "$DOTEST"/patch
- test -f "$MSG" ||
- commit_message "$1" > "$MSG"
- test -f "$AUTHOR_SCRIPT" ||
- get_author_ident_from_commit "$1" > "$AUTHOR_SCRIPT"
+ esac > "$dotest"/patch
+ test -f "$msg" ||
+ commit_message "$1" > "$msg"
+ test -f "$author_script" ||
+ get_author_ident_from_commit "$1" > "$author_script"
}
die_with_patch () {
- echo "$1" > "$DOTEST"/stopped-sha
+ echo "$1" > "$dotest"/stopped-sha
make_patch "$1"
git rerere
die "$2"
}
die_abort () {
- rm -rf "$DOTEST"
+ rm -rf "$dotest"
die "$1"
}
@@ -228,11 +228,11 @@ do_with_author () {
pick_one () {
ff=--ff
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"
- test -d "$REWRITTEN" &&
+ test -d "$rewritten" &&
pick_one_preserving_merges "$@" && return
- if test -n "$REBASE_ROOT"
+ if test -n "$rebase_root"
then
output git cherry-pick "$@"
return
@@ -253,20 +253,20 @@ pick_one_preserving_merges () {
esac
sha1=$(git rev-parse $sha1)
- if test -f "$DOTEST"/current-commit
+ if test -f "$dotest"/current-commit
then
if test "$fast_forward" = t
then
while read current_commit
do
- git rev-parse HEAD > "$REWRITTEN"/$current_commit
- done <"$DOTEST"/current-commit
- rm "$DOTEST"/current-commit ||
+ git rev-parse HEAD > "$rewritten"/$current_commit
+ done <"$dotest"/current-commit
+ rm "$dotest"/current-commit ||
die "Cannot write current commit's replacement sha1"
fi
fi
- echo $sha1 >> "$DOTEST"/current-commit
+ echo $sha1 >> "$dotest"/current-commit
# rewrite parents; if none were rewritten, we can fast-forward.
new_parents=
@@ -280,9 +280,9 @@ pick_one_preserving_merges () {
p=$(expr "$pend" : ' \([^ ]*\)')
pend="${pend# $p}"
- if test -f "$REWRITTEN"/$p
+ if test -f "$rewritten"/$p
then
- new_p=$(cat "$REWRITTEN"/$p)
+ new_p=$(cat "$rewritten"/$p)
# If the todo reordered commits, and our parent is marked for
# rewriting, but hasn't been gotten to yet, assume the user meant to
@@ -301,10 +301,10 @@ pick_one_preserving_merges () {
;;
esac
else
- if test -f "$DROPPED"/$p
+ if test -f "$dropped"/$p
then
fast_forward=f
- replacement="$(cat "$DROPPED"/$p)"
+ replacement="$(cat "$dropped"/$p)"
test -z "$replacement" && replacement=root
pend=" $replacement$pend"
else
@@ -333,18 +333,18 @@ pick_one_preserving_merges () {
test "a$1" = a-n && die "Refusing to squash a merge: $sha1"
# redo merge
- author_script=$(get_author_ident_from_commit $sha1)
- eval "$author_script"
- msg="$(commit_message $sha1)"
+ author_script_content=$(get_author_ident_from_commit $sha1)
+ eval "$author_script_content"
+ msg_content="$(commit_message $sha1)"
# No point in merging the first parent, that's HEAD
new_parents=${new_parents# $first_parent}
if ! do_with_author output \
- git merge $STRATEGY -m "$msg" $new_parents
+ git merge $strategy -m "$msg_content" $new_parents
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"
fi
- echo "$sha1 $(git rev-parse HEAD^0)" >> "$REWRITTEN_LIST"
+ echo "$sha1 $(git rev-parse HEAD^0)" >> "$rewritten_list"
;;
*)
output git cherry-pick "$@" ||
@@ -365,46 +365,46 @@ nth_string () {
}
update_squash_messages () {
- if test -f "$SQUASH_MSG"; then
- mv "$SQUASH_MSG" "$SQUASH_MSG".bak || exit
- COUNT=$(($(sed -n \
+ if test -f "$squash_msg"; then
+ mv "$squash_msg" "$squash_msg".bak || exit
+ count=$(($(sed -n \
-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,/^./{
/^$/d
- }' <"$SQUASH_MSG".bak
- } >"$SQUASH_MSG"
+ }' <"$squash_msg".bak
+ } >"$squash_msg"
else
- commit_message HEAD > "$FIXUP_MSG" || die "Cannot write $FIXUP_MSG"
- COUNT=2
+ commit_message HEAD > "$fixup_msg" || die "Cannot write $fixup_msg"
+ count=2
{
echo "# This is a combination of 2 commits."
echo "# The first commit's message is:"
echo
- cat "$FIXUP_MSG"
- } >"$SQUASH_MSG"
+ cat "$fixup_msg"
+ } >"$squash_msg"
fi
case $1 in
squash)
- rm -f "$FIXUP_MSG"
+ rm -f "$fixup_msg"
echo
- echo "# This is the $(nth_string $COUNT) commit message:"
+ echo "# This is the $(nth_string $count) commit message:"
echo
commit_message $2
;;
fixup)
echo
- echo "# The $(nth_string $COUNT) commit message will be skipped:"
+ echo "# The $(nth_string $count) commit message will be skipped:"
echo
commit_message $2 | sed -e 's/^/# /'
;;
- esac >>"$SQUASH_MSG"
+ esac >>"$squash_msg"
}
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
@@ -414,24 +414,24 @@ peek_next_command () {
# messages, effectively causing the combined commit to be used as the
# new basis for any further squash/fixups. Args: sha1 rest
die_failed_squash() {
- mv "$SQUASH_MSG" "$MSG" || exit
- rm -f "$FIXUP_MSG"
- cp "$MSG" "$GIT_DIR"/MERGE_MSG || exit
+ mv "$squash_msg" "$msg" || exit
+ rm -f "$fixup_msg"
+ cp "$msg" "$GIT_DIR"/MERGE_MSG || exit
warn
warn "Could not apply $1... $2"
die_with_patch $1 ""
}
flush_rewritten_pending() {
- test -s "$REWRITTEN_PENDING" || return
+ test -s "$rewritten_pending" || return
newsha1="$(git rev-parse HEAD^0)"
- sed "s/$/ $newsha1/" < "$REWRITTEN_PENDING" >> "$REWRITTEN_LIST"
- rm -f "$REWRITTEN_PENDING"
+ sed "s/$/ $newsha1/" < "$rewritten_pending" >> "$rewritten_list"
+ rm -f "$rewritten_pending"
}
record_in_rewritten() {
oldsha1="$(git rev-parse $1)"
- echo "$oldsha1" >> "$REWRITTEN_PENDING"
+ echo "$oldsha1" >> "$rewritten_pending"
case "$(peek_next_command)" in
squash|s|fixup|f)
@@ -443,8 +443,8 @@ record_in_rewritten() {
}
do_next () {
- rm -f "$MSG" "$AUTHOR_SCRIPT" "$AMEND" || exit
- read -r command sha1 rest < "$TODO"
+ rm -f "$msg" "$author_script" "$amend" || exit
+ read -r command sha1 rest < "$todo"
case "$command" in
'#'*|''|noop)
mark_action_done
@@ -472,9 +472,9 @@ do_next () {
mark_action_done
pick_one $sha1 ||
die_with_patch $sha1 "Could not apply $sha1... $rest"
- echo "$sha1" > "$DOTEST"/stopped-sha
+ echo "$sha1" > "$dotest"/stopped-sha
make_patch $sha1
- git rev-parse --verify HEAD > "$AMEND"
+ git rev-parse --verify HEAD > "$amend"
warn "Stopped at $sha1... $rest"
warn "You can amend the commit now, with"
warn
@@ -497,47 +497,47 @@ do_next () {
esac
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"
mark_action_done
update_squash_messages $squash_style $sha1
- author_script=$(get_author_ident_from_commit HEAD)
- echo "$author_script" > "$AUTHOR_SCRIPT"
- eval "$author_script"
+ author_script_content=$(get_author_ident_from_commit HEAD)
+ echo "$author_script_content" > "$author_script"
+ eval "$author_script_content"
output git reset --soft HEAD^
pick_one -n $sha1 || die_failed_squash $sha1 "$rest"
case "$(peek_next_command)" in
squash|s|fixup|f)
# This is an intermediate commit; its message will only be
# 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"
;;
*)
# This is the final command of this squash/fixup group
- if test -f "$FIXUP_MSG"
+ if test -f "$fixup_msg"
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"
else
- cp "$SQUASH_MSG" "$GIT_DIR"/SQUASH_MSG || exit
+ cp "$squash_msg" "$GIT_DIR"/SQUASH_MSG || exit
rm -f "$GIT_DIR"/MERGE_MSG
do_with_author git commit --no-verify -e ||
die_failed_squash $sha1 "$rest"
fi
- rm -f "$SQUASH_MSG" "$FIXUP_MSG"
+ rm -f "$squash_msg" "$fixup_msg"
;;
esac
record_in_rewritten $sha1
;;
x|"exec")
- read -r command rest < "$TODO"
+ read -r command rest < "$todo"
mark_action_done
printf 'Executing: %s\n' "$rest"
# "exec" command doesn't take a sha1 in the todo-list.
# => 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
status=$?
if test "$status" -ne 0
@@ -563,42 +563,42 @@ do_next () {
warn "Unknown command: $command $sha1 $rest"
if git rev-parse --verify -q "$sha1" >/dev/null
then
- die_with_patch $sha1 "Please fix this in the file $TODO."
+ die_with_patch $sha1 "Please fix this in the file $todo."
else
- die "Please fix this in the file $TODO."
+ die "Please fix this in the file $todo."
fi
;;
esac
- test -s "$TODO" && return
+ test -s "$todo" && return
comment_for_reflog finish &&
- HEADNAME=$(cat "$DOTEST"/head-name) &&
- OLDHEAD=$(cat "$DOTEST"/head) &&
- SHORTONTO=$(git rev-parse --short $(cat "$DOTEST"/onto)) &&
- NEWHEAD=$(git rev-parse HEAD) &&
- case $HEADNAME in
+ headname=$(cat "$dotest"/head-name) &&
+ oldhead=$(cat "$dotest"/head) &&
+ shortonto=$(git rev-parse --short $(cat "$dotest"/onto)) &&
+ newhead=$(git rev-parse HEAD) &&
+ case $headname in
refs/*)
- message="$GIT_REFLOG_ACTION: $HEADNAME onto $SHORTONTO" &&
- git update-ref -m "$message" $HEADNAME $NEWHEAD $OLDHEAD &&
- git symbolic-ref HEAD $HEADNAME
+ message="$GIT_REFLOG_ACTION: $headname onto $shortonto" &&
+ git update-ref -m "$message" $headname $newhead $oldhead &&
+ git symbolic-ref HEAD $headname
;;
esac && {
- test ! -f "$DOTEST"/verbose ||
- git diff-tree --stat $(cat "$DOTEST"/head)..HEAD
+ test ! -f "$dotest"/verbose ||
+ git diff-tree --stat $(cat "$dotest"/head)..HEAD
} &&
{
- test -s "$REWRITTEN_LIST" &&
- git notes copy --for-rewrite=rebase < "$REWRITTEN_LIST" ||
+ test -s "$rewritten_list" &&
+ git notes copy --for-rewrite=rebase < "$rewritten_list" ||
true # we don't care if this copying failed
} &&
if test -x "$GIT_DIR"/hooks/post-rewrite &&
- test -s "$REWRITTEN_LIST"; then
- "$GIT_DIR"/hooks/post-rewrite rebase < "$REWRITTEN_LIST"
+ test -s "$rewritten_list"; then
+ "$GIT_DIR"/hooks/post-rewrite rebase < "$rewritten_list"
true # we don't care if this hook failed
fi &&
- rm -rf "$DOTEST" &&
+ rm -rf "$dotest" &&
git gc --auto &&
- warn "Successfully rebased and updated $HEADNAME."
+ warn "Successfully rebased and updated $headname."
exit
}
@@ -618,11 +618,11 @@ skip_unnecessary_picks () {
# fd=3 means we skip the command
case "$fd,$command" in
3,pick|3,p)
- # pick a commit whose parent is current $ONTO -> skip
+ # pick a commit whose parent is current $onto -> skip
sha1=${rest%% *}
case "$(git rev-parse --verify --quiet "$sha1"^)" in
- "$ONTO"*)
- ONTO=$sha1
+ "$onto"*)
+ onto=$sha1
;;
*)
fd=1
@@ -637,11 +637,11 @@ skip_unnecessary_picks () {
;;
esac
printf '%s\n' "$command${rest:+ }$rest" >&$fd
- done <"$TODO" >"$TODO.new" 3>>"$DONE" &&
- mv -f "$TODO".new "$TODO" &&
+ done <"$todo" >"$todo.new" 3>>"$done" &&
+ mv -f "$todo".new "$todo" &&
case "$(peek_next_command)" in
squash|s|fixup|f)
- record_in_rewritten "$ONTO"
+ record_in_rewritten "$onto"
;;
esac ||
die "Could not skip unnecessary pick commands"
@@ -650,17 +650,17 @@ skip_unnecessary_picks () {
# check if no other options are set
is_standalone () {
test $# -eq 2 -a "$2" = '--' &&
- test -z "$ONTO" &&
- test -z "$PRESERVE_MERGES" &&
- test -z "$STRATEGY" &&
- test -z "$VERBOSE"
+ test -z "$onto" &&
+ test -z "$preserve_merges" &&
+ test -z "$strategy" &&
+ test -z "$verbose"
}
get_saved_options () {
- test -d "$REWRITTEN" && PRESERVE_MERGES=t
- test -f "$DOTEST"/strategy && STRATEGY="$(cat "$DOTEST"/strategy)"
- test -f "$DOTEST"/verbose && VERBOSE=t
- test -f "$DOTEST"/rebase-root && REBASE_ROOT=t
+ test -d "$rewritten" && preserve_merges=t
+ test -f "$dotest"/strategy && strategy="$(cat "$dotest"/strategy)"
+ test -f "$dotest"/verbose && verbose=t
+ test -f "$dotest"/rebase-root && rebase_root=t
}
# Rearrange the todo list that has both "pick sha1 msg" and
@@ -699,7 +699,7 @@ rearrange_squash () {
esac
printf '%s\n' "$pick $sha1 $message"
used="$used$sha1 "
- while read -r squash action msg
+ while read -r squash action msg_content
do
case " $used" in
*" $squash "*) continue ;;
@@ -709,13 +709,13 @@ rearrange_squash () {
+*)
action="${action#+}"
# full sha1 prefix test
- case "$msg" in "$sha1"*) emit=1;; esac ;;
+ case "$msg_content" in "$sha1"*) emit=1;; esac ;;
*)
# message prefix test
- case "$message" in "$msg"*) emit=1;; esac ;;
+ case "$message" in "$msg_content"*) emit=1;; esac ;;
esac
if test $emit = 1; then
- printf '%s\n' "$action $squash $action! $msg"
+ printf '%s\n' "$action $squash $action! $msg_content"
used="$used$squash "
fi
done <"$1.sq"
@@ -747,17 +747,17 @@ while test $# != 0
do
case "$1" in
--no-verify)
- OK_TO_SKIP_PRE_REBASE=yes
+ ok_to_skip_pre_rebase=yes
;;
--verify)
- OK_TO_SKIP_PRE_REBASE=
+ ok_to_skip_pre_rebase=
;;
--continue)
is_standalone "$@" || usage
get_saved_options
comment_for_reflog continue
- test -d "$DOTEST" || die "No interactive rebase running"
+ test -d "$dotest" || die "No interactive rebase running"
# Sanity check
git rev-parse --verify HEAD >/dev/null ||
@@ -771,26 +771,26 @@ do
then
: Nothing to commit -- skip this
else
- . "$AUTHOR_SCRIPT" ||
+ . "$author_script" ||
die "Cannot find the author identity"
- amend=
- if test -f "$AMEND"
+ current_head=
+ if test -f "$amend"
then
- amend=$(git rev-parse --verify HEAD)
- test "$amend" = $(cat "$AMEND") ||
+ current_head=$(git rev-parse --verify HEAD)
+ test "$current_head" = $(cat "$amend") ||
die "\
You have uncommitted changes in your working tree. Please, commit them
first and then run 'git rebase --continue' again."
git reset --soft HEAD^ ||
die "Cannot rewind the HEAD"
fi
- do_with_author git commit --no-verify -F "$MSG" -e || {
- test -n "$amend" && git reset --soft $amend
+ do_with_author git commit --no-verify -F "$msg" -e || {
+ test -n "$current_head" && git reset --soft $current_head
die "Could not commit staged changes."
}
fi
- record_in_rewritten "$(cat "$DOTEST"/stopped-sha)"
+ record_in_rewritten "$(cat "$dotest"/stopped-sha)"
require_clean_work_tree "rebase"
do_rest
@@ -801,17 +801,17 @@ first and then run 'git rebase --continue' again."
comment_for_reflog abort
git rerere clear
- test -d "$DOTEST" || die "No interactive rebase running"
+ test -d "$dotest" || die "No interactive rebase running"
- HEADNAME=$(cat "$DOTEST"/head-name)
- HEAD=$(cat "$DOTEST"/head)
- case $HEADNAME in
+ headname=$(cat "$dotest"/head-name)
+ head=$(cat "$dotest"/head)
+ case $headname in
refs/*)
- git symbolic-ref HEAD $HEADNAME
+ git symbolic-ref HEAD $headname
;;
esac &&
- output git reset --hard $HEAD &&
- rm -rf "$DOTEST"
+ output git reset --hard $head &&
+ rm -rf "$dotest"
exit
;;
--skip)
@@ -820,18 +820,18 @@ first and then run 'git rebase --continue' again."
comment_for_reflog skip
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
;;
-s)
case "$#,$1" in
*,*=*)
- STRATEGY="-s "$(expr "z$1" : 'z-[^=]*=\(.*\)') ;;
+ strategy="-s "$(expr "z$1" : 'z-[^=]*=\(.*\)') ;;
1,*)
usage ;;
*)
- STRATEGY="-s $2"
+ strategy="-s $2"
shift ;;
esac
;;
@@ -839,29 +839,29 @@ first and then run 'git rebase --continue' again."
# we use merge anyway
;;
-v)
- VERBOSE=t
+ verbose=t
;;
-p)
- PRESERVE_MERGES=t
+ preserve_merges=t
;;
-i)
# yeah, we know
;;
--no-ff)
- NEVER_FF=t
+ force_rebase=t
;;
--root)
- REBASE_ROOT=t
+ rebase_root=t
;;
--autosquash)
- AUTOSQUASH=t
+ autosquash=t
;;
--no-autosquash)
- AUTOSQUASH=
+ autosquash=
;;
--onto)
shift
- ONTO=$(parse_onto "$1") ||
+ onto=$(parse_onto "$1") ||
die "Does not point to a valid commit: $1"
;;
--)
@@ -872,27 +872,27 @@ first and then run 'git rebase --continue' again."
shift
done
-test -z "$REBASE_ROOT" -a $# -ge 1 -a $# -le 2 ||
-test ! -z "$REBASE_ROOT" -a $# -le 1 || usage
-test -d "$DOTEST" &&
+test -z "$rebase_root" -a $# -ge 1 -a $# -le 2 ||
+test ! -z "$rebase_root" -a $# -le 1 || usage
+test -d "$dotest" &&
die "Interactive rebase already started"
git var GIT_COMMITTER_IDENT >/dev/null ||
die "You need to set your committer info first"
-if test -z "$REBASE_ROOT"
+if test -z "$rebase_root"
then
- UPSTREAM_ARG="$1"
- UPSTREAM=$(git rev-parse --verify "$1") || die "Invalid base"
- test -z "$ONTO" && ONTO=$UPSTREAM
+ upstream_arg="$1"
+ upstream=$(git rev-parse --verify "$1") || die "Invalid base"
+ test -z "$onto" && onto=$upstream
shift
else
- UPSTREAM=
- UPSTREAM_ARG=--root
- test -z "$ONTO" &&
- die "You must specify --onto when using --root"
+ upstream=
+ upstream_arg=--root
+ test -z "$onto" &&
+ die "You must specify --onto when using --root"
fi
-run_pre_rebase_hook "$UPSTREAM_ARG" "$@"
+run_pre_rebase_hook "$upstream_arg" "$@"
comment_for_reflog start
@@ -904,76 +904,76 @@ then
die "Could not checkout $1"
fi
-HEAD=$(git rev-parse --verify HEAD) || die "No HEAD?"
-mkdir "$DOTEST" || die "Could not create temporary $DOTEST"
+head=$(git rev-parse --verify HEAD) || die "No HEAD?"
+mkdir "$dotest" || die "Could not create temporary $dotest"
-: > "$DOTEST"/interactive || die "Could not mark as interactive"
-git symbolic-ref HEAD > "$DOTEST"/head-name 2> /dev/null ||
- echo "detached HEAD" > "$DOTEST"/head-name
+: > "$dotest"/interactive || die "Could not mark as interactive"
+git symbolic-ref HEAD > "$dotest"/head-name 2> /dev/null ||
+ echo "detached HEAD" > "$dotest"/head-name
-echo $HEAD > "$DOTEST"/head
-case "$REBASE_ROOT" in
+echo $head > "$dotest"/head
+case "$rebase_root" in
'')
- rm -f "$DOTEST"/rebase-root ;;
+ rm -f "$dotest"/rebase-root ;;
*)
- : >"$DOTEST"/rebase-root ;;
+ : >"$dotest"/rebase-root ;;
esac
-echo $ONTO > "$DOTEST"/onto
-test -z "$STRATEGY" || echo "$STRATEGY" > "$DOTEST"/strategy
-test t = "$VERBOSE" && : > "$DOTEST"/verbose
-if test t = "$PRESERVE_MERGES"
+echo $onto > "$dotest"/onto
+test -z "$strategy" || echo "$strategy" > "$dotest"/strategy
+test t = "$verbose" && : > "$dotest"/verbose
+if test t = "$preserve_merges"
then
- if test -z "$REBASE_ROOT"
+ if test -z "$rebase_root"
then
- mkdir "$REWRITTEN" &&
- for c in $(git merge-base --all $HEAD $UPSTREAM)
+ mkdir "$rewritten" &&
+ for c in $(git merge-base --all $head $upstream)
do
- echo $ONTO > "$REWRITTEN"/$c ||
+ echo $onto > "$rewritten"/$c ||
die "Could not init rewritten commits"
done
else
- mkdir "$REWRITTEN" &&
- echo $ONTO > "$REWRITTEN"/root ||
+ mkdir "$rewritten" &&
+ echo $onto > "$rewritten"/root ||
die "Could not init rewritten commits"
fi
# No cherry-pick because our first pass is to determine
# parents to rewrite and skipping dropped commits would
# prematurely end our probe
- MERGES_OPTION=
- first_after_upstream="$(git rev-list --reverse --first-parent $UPSTREAM..$HEAD | head -n 1)"
+ merges_option=
+ first_after_upstream="$(git rev-list --reverse --first-parent $upstream..$head | head -n 1)"
else
- MERGES_OPTION="--no-merges --cherry-pick"
+ merges_option="--no-merges --cherry-pick"
fi
-SHORTHEAD=$(git rev-parse --short $HEAD)
-SHORTONTO=$(git rev-parse --short $ONTO)
-if test -z "$REBASE_ROOT"
- # this is now equivalent to ! -z "$UPSTREAM"
+shorthead=$(git rev-parse --short $head)
+shortonto=$(git rev-parse --short $onto)
+if test -z "$rebase_root"
+ # this is now equivalent to ! -z "$upstream"
then
- SHORTUPSTREAM=$(git rev-parse --short $UPSTREAM)
- REVISIONS=$UPSTREAM...$HEAD
- SHORTREVISIONS=$SHORTUPSTREAM..$SHORTHEAD
+ shortupstream=$(git rev-parse --short $upstream)
+ revisions=$upstream...$head
+ shortrevisions=$shortupstream..$shorthead
else
- REVISIONS=$ONTO...$HEAD
- SHORTREVISIONS=$SHORTHEAD
+ revisions=$onto...$head
+ shortrevisions=$shorthead
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 \
- $REVISIONS | \
+ $revisions | \
sed -n "s/^>//p" |
while read -r shortsha1 rest
do
- if test t != "$PRESERVE_MERGES"
+ if test t != "$preserve_merges"
then
- printf '%s\n' "pick $shortsha1 $rest" >> "$TODO"
+ printf '%s\n' "pick $shortsha1 $rest" >> "$todo"
else
sha1=$(git rev-parse $shortsha1)
- if test -z "$REBASE_ROOT"
+ if test -z "$rebase_root"
then
preserve=t
for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)
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
preserve=f
fi
@@ -983,43 +983,43 @@ do
fi
if test f = "$preserve"
then
- touch "$REWRITTEN"/$sha1
- printf '%s\n' "pick $shortsha1 $rest" >> "$TODO"
+ touch "$rewritten"/$sha1
+ printf '%s\n' "pick $shortsha1 $rest" >> "$todo"
fi
fi
done
# Watch for commits that been dropped by --cherry-pick
-if test t = "$PRESERVE_MERGES"
+if test t = "$preserve_merges"
then
- mkdir "$DROPPED"
+ mkdir "$dropped"
# Save all non-cherry-picked changes
- git rev-list $REVISIONS --left-right --cherry-pick | \
- sed -n "s/^>//p" > "$DOTEST"/not-cherry-picks
+ git rev-list $revisions --left-right --cherry-pick | \
+ sed -n "s/^>//p" > "$dotest"/not-cherry-picks
# Now all commits and note which ones are missing in
# not-cherry-picks and hence being dropped
- git rev-list $REVISIONS |
+ git rev-list $revisions |
while read rev
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
# Use -f2 because if rev-list is telling us this commit is
# not worthwhile, we don't want to track its multiple heads,
# just the history of its first-parent for others that will
# 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)
- sane_grep -v "^[a-z][a-z]* $short" <"$TODO" > "${TODO}2" ; mv "${TODO}2" "$TODO"
- rm "$REWRITTEN"/$rev
+ sane_grep -v "^[a-z][a-z]* $short" <"$todo" > "${todo}2" ; mv "${todo}2" "$todo"
+ rm "$rewritten"/$rev
fi
done
fi
-test -s "$TODO" || echo noop >> "$TODO"
-test -n "$AUTOSQUASH" && rearrange_squash "$TODO"
-cat >> "$TODO" << EOF
+test -s "$todo" || echo noop >> "$todo"
+test -n "$autosquash" && rearrange_squash "$todo"
+cat >> "$todo" << EOF
-# Rebase $SHORTREVISIONS onto $SHORTONTO
+# Rebase $shortrevisions onto $shortonto
#
# Commands:
# p, pick = use commit
@@ -1034,18 +1034,18 @@ cat >> "$TODO" << EOF
#
EOF
-has_action "$TODO" ||
+has_action "$todo" ||
die_abort "Nothing to do"
-cp "$TODO" "$TODO".backup
-git_editor "$TODO" ||
+cp "$todo" "$todo".backup
+git_editor "$todo" ||
die_abort "Could not execute editor"
-has_action "$TODO" ||
+has_action "$todo" ||
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"
-git update-ref ORIG_HEAD $HEAD
+output git checkout $onto || die_abort "could not detach HEAD"
+git update-ref ORIG_HEAD $head
do_rest
diff --git a/git-rebase.sh b/git-rebase.sh
index d689aad..dfde62f 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -36,13 +36,13 @@ cd_to_toplevel
LF='
'
-OK_TO_SKIP_PRE_REBASE=
-RESOLVEMSG="
+ok_to_skip_pre_rebase=
+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\".
"
-unset newbase
+unset onto
strategy=recursive
strategy_opts=
do_merge=
@@ -86,7 +86,7 @@ continue_merge () {
then
echo "You still have unmerged paths in your index"
echo "did you forget to use git add?"
- die "$RESOLVEMSG"
+ die "$resolvemsg"
fi
cmt=`cat "$merge_dir/current"`
@@ -96,7 +96,7 @@ continue_merge () {
then
echo "Commit failed, please do not call \"git commit\""
echo "directly, but instead do one of the following: "
- die "$RESOLVEMSG"
+ die "$resolvemsg"
fi
if test -z "$GIT_QUIET"
then
@@ -139,11 +139,11 @@ call_merge () {
;;
1)
git rerere $allow_rerere_autoupdate
- die "$RESOLVEMSG"
+ die "$resolvemsg"
;;
2)
echo "Strategy: $rv $strategy failed, try another" 1>&2
- die "$RESOLVEMSG"
+ die "$resolvemsg"
;;
*)
die "Unknown exit code ($rv) from command:" \
@@ -199,7 +199,7 @@ is_interactive () {
}
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"
then
"$GIT_DIR/hooks/pre-rebase" ${1+"$@"} ||
@@ -234,10 +234,10 @@ while test $# != 0
do
case "$1" in
--no-verify)
- OK_TO_SKIP_PRE_REBASE=yes
+ ok_to_skip_pre_rebase=yes
;;
--verify)
- OK_TO_SKIP_PRE_REBASE=
+ ok_to_skip_pre_rebase=
;;
--continue|--skip|--abort)
test $total_argc -eq 1 || usage
@@ -245,7 +245,7 @@ do
;;
--onto)
test 2 -le "$#" || usage
- newbase="$2"
+ onto="$2"
shift
;;
-M|-m|--m|--me|--mer|--merg|--merge)
@@ -359,7 +359,7 @@ continue)
finish_rb_merge
exit
fi
- git am --resolved --3way --resolvemsg="$RESOLVEMSG" &&
+ git am --resolved --3way --resolvemsg="$resolvemsg" &&
move_to_original_branch
exit
;;
@@ -378,7 +378,7 @@ skip)
finish_rb_merge
exit
fi
- git am -3 --skip --resolvemsg="$RESOLVEMSG" &&
+ git am -3 --skip --resolvemsg="$resolvemsg" &&
move_to_original_branch
exit
;;
@@ -425,7 +425,7 @@ then
unset root_flag
upstream_arg="$upstream_name"
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
root_flag="--root"
@@ -433,7 +433,7 @@ else
fi
# Make sure the branch to rebase onto is valid.
-onto_name=${newbase-"$upstream_name"}
+onto_name=${onto-"$upstream_name"}
case "$onto_name" in
*...*)
if left=${onto_name%...*} right=${onto_name#*...} &&
@@ -554,7 +554,7 @@ then
git format-patch -k --stdout --full-index --ignore-if-in-upstream \
--src-prefix=a/ --dst-prefix=b/ \
--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
ret=$?
test 0 != $ret -a -d "$apply_dir" &&
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 06/31] rebase: act on command line outside parsing loop
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
To later be able to use the command line processing in git-rebase.sh
for both interactive and non-interactive rebases, move anything that
is specific to non-interactive rebase outside of the parsing
loop. Keep only parsing and validation of command line options in the
loop.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
May want to view this patch with --ignore-all-space.
git-rebase--interactive.sh | 300 ++++++++++++++++++++++----------------------
git-rebase.sh | 126 ++++++++++---------
2 files changed, 217 insertions(+), 209 deletions(-)
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index 5873ba4..824f4f3 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -866,152 +866,158 @@ first and then run 'git rebase --continue' again."
;;
--)
shift
- test -z "$REBASE_ROOT" -a $# -ge 1 -a $# -le 2 ||
- test ! -z "$REBASE_ROOT" -a $# -le 1 || usage
- test -d "$DOTEST" &&
- die "Interactive rebase already started"
-
- git var GIT_COMMITTER_IDENT >/dev/null ||
- die "You need to set your committer info first"
-
- if test -z "$REBASE_ROOT"
- then
- UPSTREAM_ARG="$1"
- UPSTREAM=$(git rev-parse --verify "$1") || die "Invalid base"
- test -z "$ONTO" && ONTO=$UPSTREAM
- shift
- else
- UPSTREAM=
- UPSTREAM_ARG=--root
- test -z "$ONTO" &&
- die "You must specify --onto when using --root"
- fi
- run_pre_rebase_hook "$UPSTREAM_ARG" "$@"
-
- comment_for_reflog start
-
- require_clean_work_tree "rebase" "Please commit or stash them."
-
- if test ! -z "$1"
- then
- output git checkout "$1" -- ||
- die "Could not checkout $1"
- fi
+ break
+ ;;
+ esac
+ shift
+done
- HEAD=$(git rev-parse --verify HEAD) || die "No HEAD?"
- mkdir "$DOTEST" || die "Could not create temporary $DOTEST"
+test -z "$REBASE_ROOT" -a $# -ge 1 -a $# -le 2 ||
+test ! -z "$REBASE_ROOT" -a $# -le 1 || usage
+test -d "$DOTEST" &&
+ die "Interactive rebase already started"
- : > "$DOTEST"/interactive || die "Could not mark as interactive"
- git symbolic-ref HEAD > "$DOTEST"/head-name 2> /dev/null ||
- echo "detached HEAD" > "$DOTEST"/head-name
+git var GIT_COMMITTER_IDENT >/dev/null ||
+ die "You need to set your committer info first"
- echo $HEAD > "$DOTEST"/head
- case "$REBASE_ROOT" in
- '')
- rm -f "$DOTEST"/rebase-root ;;
- *)
- : >"$DOTEST"/rebase-root ;;
- esac
- echo $ONTO > "$DOTEST"/onto
- test -z "$STRATEGY" || echo "$STRATEGY" > "$DOTEST"/strategy
- test t = "$VERBOSE" && : > "$DOTEST"/verbose
- if test t = "$PRESERVE_MERGES"
- then
- if test -z "$REBASE_ROOT"
- then
- mkdir "$REWRITTEN" &&
- for c in $(git merge-base --all $HEAD $UPSTREAM)
- do
- echo $ONTO > "$REWRITTEN"/$c ||
- die "Could not init rewritten commits"
- done
- else
- mkdir "$REWRITTEN" &&
- echo $ONTO > "$REWRITTEN"/root ||
- die "Could not init rewritten commits"
- fi
- # No cherry-pick because our first pass is to determine
- # parents to rewrite and skipping dropped commits would
- # prematurely end our probe
- MERGES_OPTION=
- first_after_upstream="$(git rev-list --reverse --first-parent $UPSTREAM..$HEAD | head -n 1)"
- else
- MERGES_OPTION="--no-merges --cherry-pick"
- fi
-
- SHORTHEAD=$(git rev-parse --short $HEAD)
- SHORTONTO=$(git rev-parse --short $ONTO)
- if test -z "$REBASE_ROOT"
- # this is now equivalent to ! -z "$UPSTREAM"
- then
- SHORTUPSTREAM=$(git rev-parse --short $UPSTREAM)
- REVISIONS=$UPSTREAM...$HEAD
- SHORTREVISIONS=$SHORTUPSTREAM..$SHORTHEAD
- else
- REVISIONS=$ONTO...$HEAD
- SHORTREVISIONS=$SHORTHEAD
- fi
- git rev-list $MERGES_OPTION --pretty=oneline --abbrev-commit \
- --abbrev=7 --reverse --left-right --topo-order \
- $REVISIONS | \
- sed -n "s/^>//p" |
- while read -r shortsha1 rest
+if test -z "$REBASE_ROOT"
+then
+ UPSTREAM_ARG="$1"
+ UPSTREAM=$(git rev-parse --verify "$1") || die "Invalid base"
+ test -z "$ONTO" && ONTO=$UPSTREAM
+ shift
+else
+ UPSTREAM=
+ UPSTREAM_ARG=--root
+ test -z "$ONTO" &&
+ die "You must specify --onto when using --root"
+fi
+run_pre_rebase_hook "$UPSTREAM_ARG" "$@"
+
+comment_for_reflog start
+
+require_clean_work_tree "rebase" "Please commit or stash them."
+
+if test ! -z "$1"
+then
+ output git checkout "$1" -- ||
+ die "Could not checkout $1"
+fi
+
+HEAD=$(git rev-parse --verify HEAD) || die "No HEAD?"
+mkdir "$DOTEST" || die "Could not create temporary $DOTEST"
+
+: > "$DOTEST"/interactive || die "Could not mark as interactive"
+git symbolic-ref HEAD > "$DOTEST"/head-name 2> /dev/null ||
+ echo "detached HEAD" > "$DOTEST"/head-name
+
+echo $HEAD > "$DOTEST"/head
+case "$REBASE_ROOT" in
+'')
+ rm -f "$DOTEST"/rebase-root ;;
+*)
+ : >"$DOTEST"/rebase-root ;;
+esac
+echo $ONTO > "$DOTEST"/onto
+test -z "$STRATEGY" || echo "$STRATEGY" > "$DOTEST"/strategy
+test t = "$VERBOSE" && : > "$DOTEST"/verbose
+if test t = "$PRESERVE_MERGES"
+then
+ if test -z "$REBASE_ROOT"
+ then
+ mkdir "$REWRITTEN" &&
+ for c in $(git merge-base --all $HEAD $UPSTREAM)
do
- if test t != "$PRESERVE_MERGES"
- then
- printf '%s\n' "pick $shortsha1 $rest" >> "$TODO"
- else
- sha1=$(git rev-parse $shortsha1)
- if test -z "$REBASE_ROOT"
- then
- preserve=t
- for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)
- do
- if test -f "$REWRITTEN"/$p -a \( $p != $ONTO -o $sha1 = $first_after_upstream \)
- then
- preserve=f
- fi
- done
- else
- preserve=f
- fi
- if test f = "$preserve"
- then
- touch "$REWRITTEN"/$sha1
- printf '%s\n' "pick $shortsha1 $rest" >> "$TODO"
- fi
- fi
+ echo $ONTO > "$REWRITTEN"/$c ||
+ die "Could not init rewritten commits"
done
-
- # Watch for commits that been dropped by --cherry-pick
- if test t = "$PRESERVE_MERGES"
+ else
+ mkdir "$REWRITTEN" &&
+ echo $ONTO > "$REWRITTEN"/root ||
+ die "Could not init rewritten commits"
+ fi
+ # No cherry-pick because our first pass is to determine
+ # parents to rewrite and skipping dropped commits would
+ # prematurely end our probe
+ MERGES_OPTION=
+ first_after_upstream="$(git rev-list --reverse --first-parent $UPSTREAM..$HEAD | head -n 1)"
+else
+ MERGES_OPTION="--no-merges --cherry-pick"
+fi
+
+SHORTHEAD=$(git rev-parse --short $HEAD)
+SHORTONTO=$(git rev-parse --short $ONTO)
+if test -z "$REBASE_ROOT"
+ # this is now equivalent to ! -z "$UPSTREAM"
+then
+ SHORTUPSTREAM=$(git rev-parse --short $UPSTREAM)
+ REVISIONS=$UPSTREAM...$HEAD
+ SHORTREVISIONS=$SHORTUPSTREAM..$SHORTHEAD
+else
+ REVISIONS=$ONTO...$HEAD
+ SHORTREVISIONS=$SHORTHEAD
+fi
+git rev-list $MERGES_OPTION --pretty=oneline --abbrev-commit \
+ --abbrev=7 --reverse --left-right --topo-order \
+ $REVISIONS | \
+ sed -n "s/^>//p" |
+while read -r shortsha1 rest
+do
+ if test t != "$PRESERVE_MERGES"
+ then
+ printf '%s\n' "pick $shortsha1 $rest" >> "$TODO"
+ else
+ sha1=$(git rev-parse $shortsha1)
+ if test -z "$REBASE_ROOT"
then
- mkdir "$DROPPED"
- # Save all non-cherry-picked changes
- git rev-list $REVISIONS --left-right --cherry-pick | \
- sed -n "s/^>//p" > "$DOTEST"/not-cherry-picks
- # Now all commits and note which ones are missing in
- # not-cherry-picks and hence being dropped
- git rev-list $REVISIONS |
- while read rev
+ preserve=t
+ for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)
do
- if test -f "$REWRITTEN"/$rev -a "$(sane_grep "$rev" "$DOTEST"/not-cherry-picks)" = ""
+ if test -f "$REWRITTEN"/$p -a \( $p != $ONTO -o $sha1 = $first_after_upstream \)
then
- # Use -f2 because if rev-list is telling us this commit is
- # not worthwhile, we don't want to track its multiple heads,
- # just the history of its first-parent for others that will
- # be rebasing on top of it
- git rev-list --parents -1 $rev | cut -d' ' -s -f2 > "$DROPPED"/$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"
- rm "$REWRITTEN"/$rev
+ preserve=f
fi
done
+ else
+ preserve=f
+ fi
+ if test f = "$preserve"
+ then
+ touch "$REWRITTEN"/$sha1
+ printf '%s\n' "pick $shortsha1 $rest" >> "$TODO"
fi
+ fi
+done
- test -s "$TODO" || echo noop >> "$TODO"
- test -n "$AUTOSQUASH" && rearrange_squash "$TODO"
- cat >> "$TODO" << EOF
+# Watch for commits that been dropped by --cherry-pick
+if test t = "$PRESERVE_MERGES"
+then
+ mkdir "$DROPPED"
+ # Save all non-cherry-picked changes
+ git rev-list $REVISIONS --left-right --cherry-pick | \
+ sed -n "s/^>//p" > "$DOTEST"/not-cherry-picks
+ # Now all commits and note which ones are missing in
+ # not-cherry-picks and hence being dropped
+ git rev-list $REVISIONS |
+ while read rev
+ do
+ if test -f "$REWRITTEN"/$rev -a "$(sane_grep "$rev" "$DOTEST"/not-cherry-picks)" = ""
+ then
+ # Use -f2 because if rev-list is telling us this commit is
+ # not worthwhile, we don't want to track its multiple heads,
+ # just the history of its first-parent for others that will
+ # be rebasing on top of it
+ git rev-list --parents -1 $rev | cut -d' ' -s -f2 > "$DROPPED"/$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"
+ rm "$REWRITTEN"/$rev
+ fi
+ done
+fi
+
+test -s "$TODO" || echo noop >> "$TODO"
+test -n "$AUTOSQUASH" && rearrange_squash "$TODO"
+cat >> "$TODO" << EOF
# Rebase $SHORTREVISIONS onto $SHORTONTO
#
@@ -1028,22 +1034,18 @@ first and then run 'git rebase --continue' again."
#
EOF
- has_action "$TODO" ||
- die_abort "Nothing to do"
+has_action "$TODO" ||
+ die_abort "Nothing to do"
- cp "$TODO" "$TODO".backup
- git_editor "$TODO" ||
- die_abort "Could not execute editor"
+cp "$TODO" "$TODO".backup
+git_editor "$TODO" ||
+ die_abort "Could not execute editor"
- has_action "$TODO" ||
- die_abort "Nothing to do"
+has_action "$TODO" ||
+ die_abort "Nothing to do"
- test -d "$REWRITTEN" || test -n "$NEVER_FF" || skip_unnecessary_picks
+test -d "$REWRITTEN" || test -n "$NEVER_FF" || skip_unnecessary_picks
- output git checkout $ONTO || die_abort "could not detach HEAD"
- git update-ref ORIG_HEAD $HEAD
- do_rest
- ;;
- esac
- shift
-done
+output git checkout $ONTO || die_abort "could not detach HEAD"
+git update-ref ORIG_HEAD $HEAD
+do_rest
diff --git a/git-rebase.sh b/git-rebase.sh
index 1d34d43..e3fd001 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -62,6 +62,8 @@ in_progress=
type=
# One of {"$GIT_DIR"/rebase-apply, "$GIT_DIR"/rebase-merge}
state_dir=
+# One of {'', continue, skip, abort}, as parsed from command line
+action=
read_state () {
if test "$type" = merge
@@ -236,66 +238,10 @@ do
--verify)
OK_TO_SKIP_PRE_REBASE=
;;
- --continue)
- test -z "$in_progress" && die "No rebase in progress?"
-
- 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
- git am --resolved --3way --resolvemsg="$RESOLVEMSG" &&
- move_to_original_branch
- exit
- ;;
- --skip)
- test -z "$in_progress" && die "No rebase in progress?"
-
- 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
- git am -3 --skip --resolvemsg="$RESOLVEMSG" &&
- move_to_original_branch
- exit
- ;;
- --abort)
- test -z "$in_progress" && die "No rebase in progress?"
-
- 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
+ --continue|--skip|--abort)
+ action=${1##--}
+ shift
+ break
;;
--onto)
test 2 -le "$#" || usage
@@ -391,6 +337,66 @@ do
done
test $# -gt 2 && usage
+test -n "$action" && test -z "$in_progress" && die "No rebase in progress?"
+
+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
+ git am --resolved --3way --resolvemsg="$RESOLVEMSG" &&
+ 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
+ git am -3 --skip --resolvemsg="$RESOLVEMSG" &&
+ 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
+
# Make sure no rebase is in progress
if test -n "$in_progress"
then
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 05/31] rebase: improve detection of rebase in progress
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
Detect early on if a rebase is in progress and what type of rebase it
is (interactive, merge-based or am-based). This prepares for further
refactoring where am-based rebase will be dispatched to
git-rebase--am.sh and merge-based rebase will be dispatched to
git-rebase--merge.sh.
The idea is to use the same variables whether the type of rebase was
detected from rebase-apply/ or rebase-merge/ directories or from the
command line options. This will make the code more readable and will
later also make it easier to dispatch to the type-specific scripts.
Also show a consistent error message independent of the type of rebase
that was in progress and remove the obsolete wording about being in
the middle of a 'patch application', since that (an existing
"$GIT_DIR"/rebase-apply/applying) aborts 'git rebase' at an earlier
stage.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
Currently, the existence of rebase-merge/ is tested with 'test -d',
while the existence of rebase-apply/ is tested by creating the
directory and then deleting it again. Any good reason for this?
There were some discussions on the above subject in the first round,
but nothing conclusive, so I have left it the way it was for now.
git-rebase.sh | 80 +++++++++++++++++++++++++++++---------------------------
1 files changed, 41 insertions(+), 39 deletions(-)
diff --git a/git-rebase.sh b/git-rebase.sh
index 8c1c4ed..1d34d43 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -56,16 +56,19 @@ git_am_opt=
rebase_root=
force_rebase=
allow_rerere_autoupdate=
+# 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=
read_state () {
- if test -d "$merge_dir"
+ if test "$type" = merge
then
- state_dir="$merge_dir"
- onto_name=$(cat "$merge_dir"/onto_name) &&
- end=$(cat "$merge_dir"/end) &&
- msgnum=$(cat "$merge_dir"/msgnum)
- else
- state_dir="$apply_dir"
+ onto_name=$(cat "$state_dir"/onto_name) &&
+ end=$(cat "$state_dir"/end) &&
+ msgnum=$(cat "$state_dir"/msgnum)
fi &&
head_name=$(cat "$state_dir"/head-name) &&
onto=$(cat "$state_dir"/onto) &&
@@ -207,6 +210,23 @@ test -f "$apply_dir"/applying &&
is_interactive "$@" && exec git-rebase--interactive "$@"
+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
+
while test $# != 0
do
case "$1" in
@@ -217,8 +237,7 @@ do
OK_TO_SKIP_PRE_REBASE=
;;
--continue)
- test -d "$merge_dir" -o -d "$apply_dir" ||
- die "No rebase in progress?"
+ test -z "$in_progress" && die "No rebase in progress?"
git update-index --ignore-submodules --refresh &&
git diff-files --quiet --ignore-submodules || {
@@ -243,8 +262,7 @@ do
exit
;;
--skip)
- test -d "$merge_dir" -o -d "$apply_dir" ||
- die "No rebase in progress?"
+ test -z "$in_progress" && die "No rebase in progress?"
git reset --hard HEAD || exit $?
read_state
@@ -265,8 +283,7 @@ do
exit
;;
--abort)
- test -d "$merge_dir" -o -d "$apply_dir" ||
- die "No rebase in progress?"
+ test -z "$in_progress" && die "No rebase in progress?"
git rerere clear
read_state
@@ -374,37 +391,22 @@ do
done
test $# -gt 2 && usage
-if test $# -eq 0 && test -z "$rebase_root"
+# Make sure no rebase is in progress
+if test -n "$in_progress"
then
- test -d "$merge_dir" -o -d "$apply_dir" || usage
- test -d "$merge_dir" -o -f "$apply_dir"/rebasing &&
- die 'A rebase is in progress, try --continue, --skip or --abort.'
-fi
-
-# Make sure we do not have $apply_dir or $merge_dir
-if test -z "$do_merge"
-then
- if mkdir "$apply_dir" 2>/dev/null
- then
- rmdir "$apply_dir"
- else
- echo >&2 '
-It seems that I cannot create a rebase-apply 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 '"$apply_dir"'
+ 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"'
and run me again. I am stopping in case you still have something
valuable there.'
- exit 1
- fi
-else
- if test -d "$merge_dir"
- then
- die "previous rebase directory $merge_dir still exists." \
- 'Try git rebase (--continue | --abort | --skip)'
- fi
fi
+test $# -eq 0 && test -z "$rebase_root" && usage
+
require_clean_work_tree "rebase" "Please commit or stash them."
if test -z "$rebase_root"
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 04/31] rebase: remove unused rebase state 'prev_head'
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
The state stored in $GIT_DIR/rebase-merge/prev_head was introduced in
58634db (rebase: Allow merge strategies to be used when rebasing,
2006-06-21), but it was never used and should therefore be removed.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
git-rebase.sh | 8 --------
1 files changed, 0 insertions(+), 8 deletions(-)
diff --git a/git-rebase.sh b/git-rebase.sh
index 70948bc..8c1c4ed 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -61,7 +61,6 @@ read_state () {
if test -d "$merge_dir"
then
state_dir="$merge_dir"
- prev_head=$(cat "$merge_dir"/prev_head) &&
onto_name=$(cat "$merge_dir"/onto_name) &&
end=$(cat "$merge_dir"/end) &&
msgnum=$(cat "$merge_dir"/msgnum)
@@ -75,7 +74,6 @@ read_state () {
}
continue_merge () {
- test -n "$prev_head" || die "prev_head must be defined"
test -d "$merge_dir" || die "$merge_dir directory does not exist"
unmerged=$(git ls-files -u)
@@ -109,10 +107,6 @@ continue_merge () {
test -z "$GIT_QUIET" &&
GIT_PAGER='' git log --format=%s -1 "$cmt"
- prev_head=`git rev-parse HEAD^0`
- # save the resulting commit so we can read-tree on it later
- echo "$prev_head" > "$merge_dir/prev_head"
-
# onto the next patch:
msgnum=$(($msgnum + 1))
echo "$msgnum" >"$merge_dir/msgnum"
@@ -568,8 +562,6 @@ fi
mkdir -p "$merge_dir"
echo "$onto_name" > "$merge_dir/onto_name"
-prev_head=$orig_head
-echo "$prev_head" > "$merge_dir/prev_head"
echo "$head_name" > "$merge_dir/head-name"
echo "$onto" > "$merge_dir/onto"
echo "$orig_head" > "$merge_dir/orig-head"
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 03/31] rebase: read state outside loop
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
The 'onto_name' state used in 'git rebase --merge' is currently read
once for each commit that need to be applied. It doesn't change
between each iteration, however, so it should be moved out of the
loop. This also makes the code more readable. Also remove the unused
variable 'end'.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
git-rebase.sh | 4 ++--
1 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/git-rebase.sh b/git-rebase.sh
index 63b5683..70948bc 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -62,6 +62,7 @@ read_state () {
then
state_dir="$merge_dir"
prev_head=$(cat "$merge_dir"/prev_head) &&
+ onto_name=$(cat "$merge_dir"/onto_name) &&
end=$(cat "$merge_dir"/end) &&
msgnum=$(cat "$merge_dir"/msgnum)
else
@@ -123,9 +124,8 @@ call_merge () {
hd=$(git rev-parse --verify HEAD)
cmt_name=$(git symbolic-ref HEAD 2> /dev/null || echo HEAD)
msgnum=$(cat "$merge_dir/msgnum")
- end=$(cat "$merge_dir/end")
eval GITHEAD_$cmt='"${cmt_name##refs/heads/}~$(($end - $msgnum))"'
- eval GITHEAD_$hd='$(cat "$merge_dir/onto_name")'
+ eval GITHEAD_$hd='$onto_name'
export GITHEAD_$cmt GITHEAD_$hd
if test -n "$GIT_QUIET"
then
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 01/31] rebase: clearer names for directory variables
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1297017841-20678-1-git-send-email-martin.von.zweigbergk@gmail.com>
Instead of using the old variable name 'dotest' for
"$GIT_DIR"/rebase-merge and no variable for "$GIT_DIR"/rebase-apply,
introduce two variables 'merge_dir' and 'apply_dir' for these paths.
Signed-off-by: Martin von Zweigbergk <martin.von.zweigbergk@gmail.com>
---
git-rebase.sh | 141 +++++++++++++++++++++++++++++----------------------------
1 files changed, 71 insertions(+), 70 deletions(-)
diff --git a/git-rebase.sh b/git-rebase.sh
index cbb0ea9..72696bf 100755
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -46,7 +46,8 @@ unset newbase
strategy=recursive
strategy_opts=
do_merge=
-dotest="$GIT_DIR"/rebase-merge
+merge_dir="$GIT_DIR"/rebase-merge
+apply_dir="$GIT_DIR"/rebase-apply
prec=4
verbose=
diffstat=
@@ -58,7 +59,7 @@ allow_rerere_autoupdate=
continue_merge () {
test -n "$prev_head" || die "prev_head must be defined"
- test -d "$dotest" || die "$dotest directory does not exist"
+ test -d "$merge_dir" || die "$merge_dir directory does not exist"
unmerged=$(git ls-files -u)
if test -n "$unmerged"
@@ -68,7 +69,7 @@ continue_merge () {
die "$RESOLVEMSG"
fi
- cmt=`cat "$dotest/current"`
+ cmt=`cat "$merge_dir/current"`
if ! git diff-index --quiet --ignore-submodules HEAD --
then
if ! git commit --no-verify -C "$cmt"
@@ -81,7 +82,7 @@ continue_merge () {
then
printf "Committed: %0${prec}d " $msgnum
fi
- echo "$cmt $(git rev-parse HEAD^0)" >> "$dotest/rewritten"
+ echo "$cmt $(git rev-parse HEAD^0)" >> "$merge_dir/rewritten"
else
if test -z "$GIT_QUIET"
then
@@ -93,22 +94,22 @@ continue_merge () {
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"
+ echo "$prev_head" > "$merge_dir/prev_head"
# onto the next patch:
msgnum=$(($msgnum + 1))
- echo "$msgnum" >"$dotest/msgnum"
+ echo "$msgnum" >"$merge_dir/msgnum"
}
call_merge () {
- cmt="$(cat "$dotest/cmt.$1")"
- echo "$cmt" > "$dotest/current"
+ cmt="$(cat "$merge_dir/cmt.$1")"
+ echo "$cmt" > "$merge_dir/current"
hd=$(git rev-parse --verify HEAD)
cmt_name=$(git symbolic-ref HEAD 2> /dev/null || echo HEAD)
- msgnum=$(cat "$dotest/msgnum")
- end=$(cat "$dotest/end")
+ msgnum=$(cat "$merge_dir/msgnum")
+ end=$(cat "$merge_dir/end")
eval GITHEAD_$cmt='"${cmt_name##refs/heads/}~$(($end - $msgnum))"'
- eval GITHEAD_$hd='$(cat "$dotest/onto_name")'
+ eval GITHEAD_$hd='$(cat "$merge_dir/onto_name")'
export GITHEAD_$cmt GITHEAD_$hd
if test -n "$GIT_QUIET"
then
@@ -138,9 +139,9 @@ call_merge () {
move_to_original_branch () {
test -z "$head_name" &&
- head_name="$(cat "$dotest"/head-name)" &&
- onto="$(cat "$dotest"/onto)" &&
- orig_head="$(cat "$dotest"/orig-head)"
+ head_name="$(cat "$merge_dir"/head-name)" &&
+ onto="$(cat "$merge_dir"/onto)" &&
+ orig_head="$(cat "$merge_dir"/orig-head)"
case "$head_name" in
refs/*)
message="rebase finished: $head_name onto $onto"
@@ -154,12 +155,12 @@ move_to_original_branch () {
finish_rb_merge () {
move_to_original_branch
- git notes copy --for-rewrite=rebase < "$dotest"/rewritten
+ git notes copy --for-rewrite=rebase < "$merge_dir"/rewritten
if test -x "$GIT_DIR"/hooks/post-rewrite &&
- test -s "$dotest"/rewritten; then
- "$GIT_DIR"/hooks/post-rewrite rebase < "$dotest"/rewritten
+ test -s "$merge_dir"/rewritten; then
+ "$GIT_DIR"/hooks/post-rewrite rebase < "$merge_dir"/rewritten
fi
- rm -r "$dotest"
+ rm -r "$merge_dir"
say All done.
}
@@ -183,7 +184,7 @@ is_interactive () {
export GIT_EDITOR
fi
- test -n "$interactive_rebase" || test -f "$dotest"/interactive
+ test -n "$interactive_rebase" || test -f "$merge_dir"/interactive
}
run_pre_rebase_hook () {
@@ -195,7 +196,7 @@ run_pre_rebase_hook () {
fi
}
-test -f "$GIT_DIR"/rebase-apply/applying &&
+test -f "$apply_dir"/applying &&
die 'It looks like git-am is in progress. Cannot rebase.'
is_interactive "$@" && exec git-rebase--interactive "$@"
@@ -210,7 +211,7 @@ do
OK_TO_SKIP_PRE_REBASE=
;;
--continue)
- test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
+ test -d "$merge_dir" -o -d "$apply_dir" ||
die "No rebase in progress?"
git update-index --ignore-submodules --refresh &&
@@ -219,13 +220,13 @@ do
echo "mark them as resolved using git add"
exit 1
}
- if test -d "$dotest"
+ if test -d "$merge_dir"
then
- prev_head=$(cat "$dotest/prev_head")
- end=$(cat "$dotest/end")
- msgnum=$(cat "$dotest/msgnum")
- onto=$(cat "$dotest/onto")
- GIT_QUIET=$(cat "$dotest/quiet")
+ prev_head=$(cat "$merge_dir/prev_head")
+ end=$(cat "$merge_dir/end")
+ msgnum=$(cat "$merge_dir/msgnum")
+ onto=$(cat "$merge_dir/onto")
+ GIT_QUIET=$(cat "$merge_dir/quiet")
continue_merge
while test "$msgnum" -le "$end"
do
@@ -235,28 +236,28 @@ do
finish_rb_merge
exit
fi
- head_name=$(cat "$GIT_DIR"/rebase-apply/head-name) &&
- onto=$(cat "$GIT_DIR"/rebase-apply/onto) &&
- orig_head=$(cat "$GIT_DIR"/rebase-apply/orig-head) &&
- GIT_QUIET=$(cat "$GIT_DIR"/rebase-apply/quiet)
+ head_name=$(cat "$apply_dir"/head-name) &&
+ onto=$(cat "$apply_dir"/onto) &&
+ orig_head=$(cat "$apply_dir"/orig-head) &&
+ GIT_QUIET=$(cat "$apply_dir"/quiet)
git am --resolved --3way --resolvemsg="$RESOLVEMSG" &&
move_to_original_branch
exit
;;
--skip)
- test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
+ test -d "$merge_dir" -o -d "$apply_dir" ||
die "No rebase in progress?"
git reset --hard HEAD || exit $?
- if test -d "$dotest"
+ if test -d "$merge_dir"
then
git rerere clear
- prev_head=$(cat "$dotest/prev_head")
- end=$(cat "$dotest/end")
- msgnum=$(cat "$dotest/msgnum")
+ prev_head=$(cat "$merge_dir/prev_head")
+ end=$(cat "$merge_dir/end")
+ msgnum=$(cat "$merge_dir/msgnum")
msgnum=$(($msgnum + 1))
- onto=$(cat "$dotest/onto")
- GIT_QUIET=$(cat "$dotest/quiet")
+ onto=$(cat "$merge_dir/onto")
+ GIT_QUIET=$(cat "$merge_dir/quiet")
while test "$msgnum" -le "$end"
do
call_merge "$msgnum"
@@ -265,31 +266,31 @@ do
finish_rb_merge
exit
fi
- head_name=$(cat "$GIT_DIR"/rebase-apply/head-name) &&
- onto=$(cat "$GIT_DIR"/rebase-apply/onto) &&
- orig_head=$(cat "$GIT_DIR"/rebase-apply/orig-head) &&
- GIT_QUIET=$(cat "$GIT_DIR"/rebase-apply/quiet)
+ head_name=$(cat "$apply_dir"/head-name) &&
+ onto=$(cat "$apply_dir"/onto) &&
+ orig_head=$(cat "$apply_dir"/orig-head) &&
+ GIT_QUIET=$(cat "$apply_dir"/quiet)
git am -3 --skip --resolvemsg="$RESOLVEMSG" &&
move_to_original_branch
exit
;;
--abort)
- test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
+ test -d "$merge_dir" -o -d "$apply_dir" ||
die "No rebase in progress?"
git rerere clear
- test -d "$dotest" || dotest="$GIT_DIR"/rebase-apply
+ test -d "$merge_dir" || merge_dir="$apply_dir"
- head_name="$(cat "$dotest"/head-name)" &&
+ head_name="$(cat "$merge_dir"/head-name)" &&
case "$head_name" in
refs/*)
git symbolic-ref HEAD $head_name ||
die "Could not move back to $head_name"
;;
esac
- git reset --hard $(cat "$dotest/orig-head")
- rm -r "$dotest"
+ git reset --hard $(cat "$merge_dir/orig-head")
+ rm -r "$merge_dir"
exit
;;
--onto)
@@ -388,31 +389,31 @@ test $# -gt 2 && usage
if test $# -eq 0 && test -z "$rebase_root"
then
- test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply || usage
- test -d "$dotest" -o -f "$GIT_DIR"/rebase-apply/rebasing &&
+ test -d "$merge_dir" -o -d "$apply_dir" || usage
+ test -d "$merge_dir" -o -f "$apply_dir"/rebasing &&
die 'A rebase is in progress, try --continue, --skip or --abort.'
fi
-# Make sure we do not have $GIT_DIR/rebase-apply
+# Make sure we do not have $apply_dir or $merge_dir
if test -z "$do_merge"
then
- if mkdir "$GIT_DIR"/rebase-apply 2>/dev/null
+ if mkdir "$apply_dir" 2>/dev/null
then
- rmdir "$GIT_DIR"/rebase-apply
+ rmdir "$apply_dir"
else
echo >&2 '
It seems that I cannot create a rebase-apply 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 '"$GIT_DIR"'/rebase-apply
+ rm -fr '"$apply_dir"'
and run me again. I am stopping in case you still have something
valuable there.'
exit 1
fi
else
- if test -d "$dotest"
+ if test -d "$merge_dir"
then
- die "previous rebase directory $dotest still exists." \
+ die "previous rebase directory $merge_dir still exists." \
'Try git rebase (--continue | --abort | --skip)'
fi
fi
@@ -561,35 +562,35 @@ then
git am $git_am_opt --rebasing --resolvemsg="$RESOLVEMSG" &&
move_to_original_branch
ret=$?
- test 0 != $ret -a -d "$GIT_DIR"/rebase-apply &&
- echo $head_name > "$GIT_DIR"/rebase-apply/head-name &&
- echo $onto > "$GIT_DIR"/rebase-apply/onto &&
- echo $orig_head > "$GIT_DIR"/rebase-apply/orig-head &&
- echo "$GIT_QUIET" > "$GIT_DIR"/rebase-apply/quiet
+ 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"
exit $ret
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"
-echo "$onto_name" > "$dotest/onto_name"
+mkdir -p "$merge_dir"
+echo "$onto" > "$merge_dir/onto"
+echo "$onto_name" > "$merge_dir/onto_name"
prev_head=$orig_head
-echo "$prev_head" > "$dotest/prev_head"
-echo "$orig_head" > "$dotest/orig-head"
-echo "$head_name" > "$dotest/head-name"
-echo "$GIT_QUIET" > "$dotest/quiet"
+echo "$prev_head" > "$merge_dir/prev_head"
+echo "$orig_head" > "$merge_dir/orig-head"
+echo "$head_name" > "$merge_dir/head-name"
+echo "$GIT_QUIET" > "$merge_dir/quiet"
msgnum=0
for cmt in `git rev-list --reverse --no-merges "$revisions"`
do
msgnum=$(($msgnum + 1))
- echo "$cmt" > "$dotest/cmt.$msgnum"
+ echo "$cmt" > "$merge_dir/cmt.$msgnum"
done
-echo 1 >"$dotest/msgnum"
-echo $msgnum >"$dotest/end"
+echo 1 >"$merge_dir/msgnum"
+echo $msgnum >"$merge_dir/end"
end=$msgnum
msgnum=1
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply related
* [PATCH v2 00/31] refactor rebase
From: Martin von Zweigbergk @ 2011-02-06 18:43 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Johannes Schindelin, Johannes Sixt,
Christian Couder, Thomas Rast, Martin von Zweigbergk
In-Reply-To: <1293528648-21873-1-git-send-email-martin.von.zweigbergk@gmail.com>
Changes since the first round:
As suggested by Johannes Sixt, source git-rebase--interactive.sh and
friends instead of executing them.
As suggested by Thomas Rast, downcase all variables for consitency.
Based on current master, including Jeff's two patches to rebase.
There are also a few other minor changes, but see the notes in each
patch for more information.
Martin von Zweigbergk (31):
rebase: clearer names for directory variables
rebase: refactor reading of state
rebase: read state outside loop
rebase: remove unused rebase state 'prev_head'
rebase: improve detection of rebase in progress
rebase: act on command line outside parsing loop
rebase: stricter check of standalone sub command
rebase: align variable names
rebase: align variable content
rebase: factor out command line option processing
rebase -i: remove now unnecessary directory checks
rebase: reorder validation steps
rebase: factor out reference parsing
rebase: factor out clean work tree check
rebase: factor out call to pre-rebase hook
rebase -i: support --stat
rebase: remove $branch as synonym for $orig_head
rebase: extract merge code to new source file
rebase: extract am code to new source file
rebase: show consistent conflict resolution hint
rebase -i: align variable names
rebase: make -v a tiny bit more verbose
rebase: factor out sub command handling
rebase: extract code for writing basic state
rebase: remember verbose option
rebase: remember strategy and strategy options
rebase -m: remember allow_rerere_autoupdate option
rebase -m: don't print exit code 2 when merge fails
git-rebase--am: remove unnecessary --3way option
rebase -i: don't read unused variable preserve_merges
rebase -i: remove unnecessary state rebase-root
.gitignore | 2 +
Makefile | 2 +
git-rebase--am.sh | 30 ++
git-rebase--interactive.sh | 751 +++++++++++++++----------------------------
git-rebase--merge.sh | 151 +++++++++
git-rebase.sh | 482 +++++++++++-----------------
t/t3403-rebase-skip.sh | 5 +
t/t3407-rebase-abort.sh | 10 +
t/t3418-rebase-continue.sh | 55 ++++
9 files changed, 707 insertions(+), 781 deletions(-)
create mode 100644 git-rebase--am.sh
create mode 100644 git-rebase--merge.sh
--
1.7.4.rc2.33.g8a14f
^ permalink raw reply
* Re: ignoring file modes completely
From: Dmitry Potapov @ 2011-02-06 18:10 UTC (permalink / raw)
To: rkitover; +Cc: git
In-Reply-To: <4D4EC8E6.2090200@io.com>
On Sun, Feb 06, 2011 at 11:14:30AM -0500, Rafael Kitover wrote:
> $ git diff HEAD
> diff --git a/README b/README
> old mode 100644
> new mode 100755
> $ git config --global core.filemode
> false
This is because core.filemode is set in the local configuration:
$ git config core.filemode
true
Git automatically detects if chmod(2) is supported on the current file
system and sets core.filemode to the corresponding value. Because cygwin
emulates chmod(), git sets core.filemode to true.
Dmitry
^ permalink raw reply
* Re: [PATCH 1/8] git-p4: test script
From: Vitor Antunes @ 2011-02-06 18:00 UTC (permalink / raw)
To: git
In-Reply-To: <20110205225105.GB30963@arf.padd.com>
Hi Pete,
Kudos on this patch! I'm looking forward in having it accepted, so that I can
create some test cases for my latest patches ;)
Thanks,
Vitor Antunes
^ permalink raw reply
* Re: [PATCH 1/2] git-p4: Improve rename detection support.
From: Vitor Antunes @ 2011-02-06 12:39 UTC (permalink / raw)
To: Pete Wyckoff
In-Reply-To: <20110206002113.GA31245@arf.padd.com>
Hi Pete,
On Sun, Feb 6, 2011 at 12:21 AM, Pete Wyckoff <pw@padd.com> wrote:
> The comparisons confuse me. detectRenames != "false" > 0 ?
> How about just detectRenames == "true"?
The "> 0" was for the length check. I somehow (*feeling embarrassed*)
misplaced that code...
> You could rename the existing self.detectRename to add an "s" so
> it all makes a bit more sense.
>
> if not self.detectRenames:
> # not explicitly set, check the config variable
> b = gitConfig("git-p4.detectRenames")
> if b == "true":
> self.detectRenames = "-M"
>
> if self.detectRenames:
> diffOpts = "-M"
> else:
> diffOpts = ""
Seems like a better idea. I kind of like the original code to set
diffOpts, so I would prefer to keep it. What do you think of (didn't
test it):
if not self.detectRenames:
# If not explicitly set check the config variable
self.detectRenames =
gitConfig("git-p4.detectRenames").lower() == "true"
diffOpts = ("", "-M")[self.detectRenames]
>> diff = read_pipe_lines("git diff-tree -r %s \"%s^\" \"%s\"" % (diffOpts, id, id))
>> filesToAdd = set()
>> filesToDelete = set()
>> @@ -640,7 +646,8 @@ class P4Submit(Command):
>> elif modifier == "R":
>> src, dest = diff['src'], diff['dst']
>> p4_system("integrate -Dt \"%s\" \"%s\"" % (src, dest))
>> - p4_system("edit \"%s\"" % (dest))
>> + if diff['src_sha1'] != diff['dst_sha1']:
>> + p4_system("edit \"%s\"" % (dest))
>> if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
>> filesToChangeExecBit[dest] = diff['dst_mode']
>> os.unlink(dest)
>
> If you rename the file and also cause its perms to change (say
> add +x), does it still work if dest is not open?
This is a very good point. I will also open the file for edit when
there is a mode change.
Thanks!
--
Vitor Antunes
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox