git.oblomov.eu Git - git/blob - git-rebase.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2005 Junio C Hamano.
   4 #
   5
   6 USAGE='[--interactive | -i] [-v] [--onto <newbase>] <upstream> [<branch>]'
   7 LONG_USAGE='git-rebase replaces <branch> with a new branch of the
   8 same name.  When the --onto option is provided the new branch starts
   9 out with a HEAD equal to <newbase>, otherwise it is equal to <upstream>
  10 It then attempts to create a new commit for each commit from the original
  11 <branch> that does not exist in the <upstream> branch.
  12
  13 It is possible that a merge failure will prevent this process from being
  14 completely automatic.  You will have to resolve any such merge failure
  15 and run git rebase --continue.  Another option is to bypass the commit
  16 that caused the merge failure with git rebase --skip.  To restore the
  17 original <branch> and remove the .git/rebase-apply working files, use the
  18 command git rebase --abort instead.
  19
  20 Note that if <branch> is not specified on the command line, the
  21 currently checked out branch is used.
  22
  23 Example:       git-rebase master~1 topic
  24
  25         A---B---C topic                   A'\''--B'\''--C'\'' topic
  26        /                   -->           /
  27   D---E---F---G master          D---E---F---G master
  28 '
  29
  30 SUBDIRECTORY_OK=Yes
  31 OPTIONS_SPEC=
  32 . git-sh-setup
  33 set_reflog_action rebase
  34 require_work_tree
  35 cd_to_toplevel
  36
  37 OK_TO_SKIP_PRE_REBASE=
  38 RESOLVEMSG="
  39 When you have resolved this problem run \"git rebase --continue\".
  40 If you would prefer to skip this patch, instead run \"git rebase --skip\".
  41 To restore the original branch and stop rebasing run \"git rebase --abort\".
  42 "
  43 unset newbase
  44 strategy=recursive
  45 do_merge=
  46 dotest="$GIT_DIR"/rebase-merge
  47 prec=4
  48 verbose=
  49 git_am_opt=
  50
  51 continue_merge () {
  52         test -n "$prev_head" || die "prev_head must be defined"
  53         test -d "$dotest" || die "$dotest directory does not exist"
  54
  55         unmerged=$(git ls-files -u)
  56         if test -n "$unmerged"
  57         then
  58                 echo "You still have unmerged paths in your index"
  59                 echo "did you forget to use git add?"
  60                 die "$RESOLVEMSG"
  61         fi
  62
  63         cmt=`cat "$dotest/current"`
  64         if ! git diff-index --quiet --ignore-submodules HEAD --
  65         then
  66                 if ! git commit --no-verify -C "$cmt"
  67                 then
  68                         echo "Commit failed, please do not call \"git commit\""
  69                         echo "directly, but instead do one of the following: "
  70                         die "$RESOLVEMSG"
  71                 fi
  72                 printf "Committed: %0${prec}d " $msgnum
  73         else
  74                 printf "Already applied: %0${prec}d " $msgnum
  75         fi
  76         git rev-list --pretty=oneline -1 "$cmt" | sed -e 's/^[^ ]* //'
  77
  78         prev_head=`git rev-parse HEAD^0`
  79         # save the resulting commit so we can read-tree on it later
  80         echo "$prev_head" > "$dotest/prev_head"
  81
  82         # onto the next patch:
  83         msgnum=$(($msgnum + 1))
  84         echo "$msgnum" >"$dotest/msgnum"
  85 }
  86
  87 call_merge () {
  88         cmt="$(cat "$dotest/cmt.$1")"
  89         echo "$cmt" > "$dotest/current"
  90         hd=$(git rev-parse --verify HEAD)
  91         cmt_name=$(git symbolic-ref HEAD 2> /dev/null || echo HEAD)
  92         msgnum=$(cat "$dotest/msgnum")
  93         end=$(cat "$dotest/end")
  94         eval GITHEAD_$cmt='"${cmt_name##refs/heads/}~$(($end - $msgnum))"'
  95         eval GITHEAD_$hd='$(cat "$dotest/onto_name")'
  96         export GITHEAD_$cmt GITHEAD_$hd
  97         git-merge-$strategy "$cmt^" -- "$hd" "$cmt"
  98         rv=$?
  99         case "$rv" in
 100         0)
 101                 unset GITHEAD_$cmt GITHEAD_$hd
 102                 return
 103                 ;;
 104         1)
 105                 git rerere
 106                 die "$RESOLVEMSG"
 107                 ;;
 108         2)
 109                 echo "Strategy: $rv $strategy failed, try another" 1>&2
 110                 die "$RESOLVEMSG"
 111                 ;;
 112         *)
 113                 die "Unknown exit code ($rv) from command:" \
 114                         "git-merge-$strategy $cmt^ -- HEAD $cmt"
 115                 ;;
 116         esac
 117 }
 118
 119 move_to_original_branch () {
 120         test -z "$head_name" &&
 121                 head_name="$(cat "$dotest"/head-name)" &&
 122                 onto="$(cat "$dotest"/onto)" &&
 123                 orig_head="$(cat "$dotest"/orig-head)"
 124         case "$head_name" in
 125         refs/*)
 126                 message="rebase finished: $head_name onto $onto"
 127                 git update-ref -m "$message" \
 128                         $head_name $(git rev-parse HEAD) $orig_head &&
 129                 git symbolic-ref HEAD $head_name ||
 130                 die "Could not move back to $head_name"
 131                 ;;
 132         esac
 133 }
 134
 135 finish_rb_merge () {
 136         move_to_original_branch
 137         rm -r "$dotest"
 138         echo "All done."
 139 }
 140
 141 is_interactive () {
 142         while test $# != 0
 143         do
 144                 case "$1" in
 145                         -i|--interactive)
 146                                 interactive_rebase=explicit
 147                                 break
 148                         ;;
 149                         -p|--preserve-merges)
 150                                 interactive_rebase=implied
 151                         ;;
 152                 esac
 153                 shift
 154         done
 155
 156         if [ "$interactive_rebase" = implied ]; then
 157                 GIT_EDITOR=:
 158                 export GIT_EDITOR
 159         fi
 160
 161         test -n "$interactive_rebase" || test -f "$dotest"/interactive
 162 }
 163
 164 run_pre_rebase_hook () {
 165         if test -z "$OK_TO_SKIP_PRE_REBASE" &&
 166            test -x "$GIT_DIR/hooks/pre-rebase"
 167         then
 168                 "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} || {
 169                         echo >&2 "The pre-rebase hook refused to rebase."
 170                         exit 1
 171                 }
 172         fi
 173 }
 174
 175 test -f "$GIT_DIR"/rebase-apply/applying &&
 176         die 'It looks like git-am is in progress. Cannot rebase.'
 177
 178 is_interactive "$@" && exec git-rebase--interactive "$@"
 179
 180 if test $# -eq 0
 181 then
 182         test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply || usage
 183         test -d "$dotest" -o -f "$GIT_DIR"/rebase-apply/rebasing &&
 184                 die 'A rebase is in progress, try --continue, --skip or --abort.'
 185         die "No arguments given and $GIT_DIR/rebase-apply already exists."
 186 fi
 187
 188 while test $# != 0
 189 do
 190         case "$1" in
 191         --no-verify)
 192                 OK_TO_SKIP_PRE_REBASE=yes
 193                 ;;
 194         --continue)
 195                 test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
 196                         die "No rebase in progress?"
 197
 198                 git diff-files --quiet --ignore-submodules || {
 199                         echo "You must edit all merge conflicts and then"
 200                         echo "mark them as resolved using git add"
 201                         exit 1
 202                 }
 203                 if test -d "$dotest"
 204                 then
 205                         prev_head=$(cat "$dotest/prev_head")
 206                         end=$(cat "$dotest/end")
 207                         msgnum=$(cat "$dotest/msgnum")
 208                         onto=$(cat "$dotest/onto")
 209                         continue_merge
 210                         while test "$msgnum" -le "$end"
 211                         do
 212                                 call_merge "$msgnum"
 213                                 continue_merge
 214                         done
 215                         finish_rb_merge
 216                         exit
 217                 fi
 218                 head_name=$(cat "$GIT_DIR"/rebase-apply/head-name) &&
 219                 onto=$(cat "$GIT_DIR"/rebase-apply/onto) &&
 220                 orig_head=$(cat "$GIT_DIR"/rebase-apply/orig-head) &&
 221                 git am --resolved --3way --resolvemsg="$RESOLVEMSG" &&
 222                 move_to_original_branch
 223                 exit
 224                 ;;
 225         --skip)
 226                 test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
 227                         die "No rebase in progress?"
 228
 229                 git reset --hard HEAD || exit $?
 230                 if test -d "$dotest"
 231                 then
 232                         git rerere clear
 233                         prev_head=$(cat "$dotest/prev_head")
 234                         end=$(cat "$dotest/end")
 235                         msgnum=$(cat "$dotest/msgnum")
 236                         msgnum=$(($msgnum + 1))
 237                         onto=$(cat "$dotest/onto")
 238                         while test "$msgnum" -le "$end"
 239                         do
 240                                 call_merge "$msgnum"
 241                                 continue_merge
 242                         done
 243                         finish_rb_merge
 244                         exit
 245                 fi
 246                 head_name=$(cat "$GIT_DIR"/rebase-apply/head-name) &&
 247                 onto=$(cat "$GIT_DIR"/rebase-apply/onto) &&
 248                 orig_head=$(cat "$GIT_DIR"/rebase-apply/orig-head) &&
 249                 git am -3 --skip --resolvemsg="$RESOLVEMSG" &&
 250                 move_to_original_branch
 251                 exit
 252                 ;;
 253         --abort)
 254                 test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
 255                         die "No rebase in progress?"
 256
 257                 git rerere clear
 258                 if test -d "$dotest"
 259                 then
 260                         move_to_original_branch
 261                 else
 262                         dotest="$GIT_DIR"/rebase-apply
 263                         move_to_original_branch
 264                 fi
 265                 git reset --hard $(cat "$dotest/orig-head")
 266                 rm -r "$dotest"
 267                 exit
 268                 ;;
 269         --onto)
 270                 test 2 -le "$#" || usage
 271                 newbase="$2"
 272                 shift
 273                 ;;
 274         -M|-m|--m|--me|--mer|--merg|--merge)
 275                 do_merge=t
 276                 ;;
 277         -s=*|--s=*|--st=*|--str=*|--stra=*|--strat=*|--strate=*|\
 278                 --strateg=*|--strategy=*|\
 279         -s|--s|--st|--str|--stra|--strat|--strate|--strateg|--strategy)
 280                 case "$#,$1" in
 281                 *,*=*)
 282                         strategy=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
 283                 1,*)
 284                         usage ;;
 285                 *)
 286                         strategy="$2"
 287                         shift ;;
 288                 esac
 289                 do_merge=t
 290                 ;;
 291         -v|--verbose)
 292                 verbose=t
 293                 ;;
 294         --whitespace=*)
 295                 git_am_opt="$git_am_opt $1"
 296                 ;;
 297         -C*)
 298                 git_am_opt="$git_am_opt $1"
 299                 ;;
 300         -*)
 301                 usage
 302                 ;;
 303         *)
 304                 break
 305                 ;;
 306         esac
 307         shift
 308 done
 309
 310 # Make sure we do not have $GIT_DIR/rebase-apply
 311 if test -z "$do_merge"
 312 then
 313         if mkdir "$GIT_DIR"/rebase-apply 2>/dev/null
 314         then
 315                 rmdir "$GIT_DIR"/rebase-apply
 316         else
 317                 echo >&2 '
 318 It seems that I cannot create a rebase-apply directory, and
 319 I wonder if you are in the middle of patch application or another
 320 rebase.  If that is not the case, please
 321         rm -fr '"$GIT_DIR"'/rebase-apply
 322 and run me again.  I am stopping in case you still have something
 323 valuable there.'
 324                 exit 1
 325         fi
 326 else
 327         if test -d "$dotest"
 328         then
 329                 die "previous rebase directory $dotest still exists." \
 330                         'Try git rebase (--continue | --abort | --skip)'
 331         fi
 332 fi
 333
 334 # The tree must be really really clean.
 335 if ! git update-index --ignore-submodules --refresh; then
 336         echo >&2 "cannot rebase: you have unstaged changes"
 337         exit 1
 338 fi
 339 diff=$(git diff-index --cached --name-status -r --ignore-submodules HEAD --)
 340 case "$diff" in
 341 ?*)     echo >&2 "cannot rebase: your index contains uncommitted changes"
 342         echo >&2 "$diff"
 343         exit 1
 344         ;;
 345 esac
 346
 347 # The upstream head must be given.  Make sure it is valid.
 348 upstream_name="$1"
 349 upstream=`git rev-parse --verify "${upstream_name}^0"` ||
 350     die "invalid upstream $upstream_name"
 351
 352 # Make sure the branch to rebase onto is valid.
 353 onto_name=${newbase-"$upstream_name"}
 354 onto=$(git rev-parse --verify "${onto_name}^0") || exit
 355
 356 # If a hook exists, give it a chance to interrupt
 357 run_pre_rebase_hook ${1+"$@"}
 358
 359 # If the branch to rebase is given, that is the branch we will rebase
 360 # $branch_name -- branch being rebased, or HEAD (already detached)
 361 # $orig_head -- commit object name of tip of the branch before rebasing
 362 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
 363 switch_to=
 364 case "$#" in
 365 2)
 366         # Is it "rebase other $branchname" or "rebase other $commit"?
 367         branch_name="$2"
 368         switch_to="$2"
 369
 370         if git show-ref --verify --quiet -- "refs/heads/$2" &&
 371            branch=$(git rev-parse -q --verify "refs/heads/$2")
 372         then
 373                 head_name="refs/heads/$2"
 374         elif branch=$(git rev-parse -q --verify "$2")
 375         then
 376                 head_name="detached HEAD"
 377         else
 378                 usage
 379         fi
 380         ;;
 381 *)
 382         # Do not need to switch branches, we are already on it.
 383         if branch_name=`git symbolic-ref -q HEAD`
 384         then
 385                 head_name=$branch_name
 386                 branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
 387         else
 388                 head_name="detached HEAD"
 389                 branch_name=HEAD ;# detached
 390         fi
 391         branch=$(git rev-parse --verify "${branch_name}^0") || exit
 392         ;;
 393 esac
 394 orig_head=$branch
 395
 396 # Now we are rebasing commits $upstream..$branch on top of $onto
 397
 398 # Check if we are already based on $onto with linear history,
 399 # but this should be done only when upstream and onto are the same.
 400 mb=$(git merge-base "$onto" "$branch")
 401 if test "$upstream" = "$onto" && test "$mb" = "$onto" &&
 402         # linear history?
 403         ! (git rev-list --parents "$onto".."$branch" | grep " .* ") > /dev/null
 404 then
 405         # Lazily switch to the target branch if needed...
 406         test -z "$switch_to" || git checkout "$switch_to"
 407         echo >&2 "Current branch $branch_name is up to date."
 408         exit 0
 409 fi
 410
 411 if test -n "$verbose"
 412 then
 413         echo "Changes from $mb to $onto:"
 414         # We want color (if set), but no pager
 415         GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
 416 fi
 417
 418 # Detach HEAD and reset the tree
 419 echo "First, rewinding head to replay your work on top of it..."
 420 git checkout -q "$onto^0" || die "could not detach HEAD"
 421 git update-ref ORIG_HEAD $branch
 422
 423 # If the $onto is a proper descendant of the tip of the branch, then
 424 # we just fast forwarded.
 425 if test "$mb" = "$branch"
 426 then
 427         echo >&2 "Fast-forwarded $branch_name to $onto_name."
 428         move_to_original_branch
 429         exit 0
 430 fi
 431
 432 if test -z "$do_merge"
 433 then
 434         git format-patch -k --stdout --full-index --ignore-if-in-upstream \
 435                 "$upstream..$orig_head" |
 436         git am $git_am_opt --rebasing --resolvemsg="$RESOLVEMSG" &&
 437         move_to_original_branch
 438         ret=$?
 439         test 0 != $ret -a -d "$GIT_DIR"/rebase-apply &&
 440                 echo $head_name > "$GIT_DIR"/rebase-apply/head-name &&
 441                 echo $onto > "$GIT_DIR"/rebase-apply/onto &&
 442                 echo $orig_head > "$GIT_DIR"/rebase-apply/orig-head
 443         exit $ret
 444 fi
 445
 446 # start doing a rebase with git-merge
 447 # this is rename-aware if the recursive (default) strategy is used
 448
 449 mkdir -p "$dotest"
 450 echo "$onto" > "$dotest/onto"
 451 echo "$onto_name" > "$dotest/onto_name"
 452 prev_head=$orig_head
 453 echo "$prev_head" > "$dotest/prev_head"
 454 echo "$orig_head" > "$dotest/orig-head"
 455 echo "$head_name" > "$dotest/head-name"
 456
 457 msgnum=0
 458 for cmt in `git rev-list --reverse --no-merges "$upstream..$orig_head"`
 459 do
 460         msgnum=$(($msgnum + 1))
 461         echo "$cmt" > "$dotest/cmt.$msgnum"
 462 done
 463
 464 echo 1 >"$dotest/msgnum"
 465 echo $msgnum >"$dotest/end"
 466
 467 end=$msgnum
 468 msgnum=1
 469
 470 while test "$msgnum" -le "$end"
 471 do
 472         call_merge "$msgnum"
 473         continue_merge
 474 done
 475
 476 finish_rb_merge