rebase: act on command line outside parsing loop

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>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index 5873ba4bc3b2a94cd7754ae572072fd745dc059d..824f4f303d9de2cf779981464888a03cfda17a01 100755 (executable)
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -866,152 +866,158 @@ first and then run 'git rebase --continue' again."
                ;;
        --)
                shift
                ;;
        --)
                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
                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
                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
                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
                        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
                                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
                                fi
                        done

+               else
+                       preserve=f
+               fi
+               if test f = "$preserve"
+               then
+                       touch "$REWRITTEN"/$sha1
+                       printf '%s\n' "pick $shortsha1 $rest" >> "$TODO"

                fi
                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
 #
 
 # Rebase $SHORTREVISIONS onto $SHORTONTO
 #


@@ -1028,22 +1034,18 @@ first and then run 'git rebase --continue' again."
 #
 EOF
 
 #
 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 1d34d43440052015e627f6bcb59344eef1be371d..e3fd001f7bc07ba3cb11586873514c5380d52562 100755 (executable)
--- 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=
 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
 
 read_state () {
        if test "$type" = merge


@@ -236,66 +238,10 @@ do
        --verify)
                OK_TO_SKIP_PRE_REBASE=
                ;;
        --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
                ;;
        --onto)
                test 2 -le "$#" || usage


@@ -391,6 +337,66 @@ do
 done
 test $# -gt 2 && usage
 
 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
 # Make sure no rebase is in progress
 if test -n "$in_progress"
 then