git-rebase.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2005 Junio C Hamano.
   4 #
   5
   6 SUBDIRECTORY_OK=Yes
   7 OPTIONS_KEEPDASHDASH=
   8 OPTIONS_SPEC="\
   9 git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>]
  10 git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] --root [<branch>]
  11 git-rebase --continue | --abort | --skip | --edit-todo
  12 --
  13  Available options are
  14 v,verbose!         display a diffstat of what changed upstream
  15 q,quiet!           be quiet. implies --no-stat
  16 autostash!         automatically stash/stash pop before and after
  17 onto=!             rebase onto given branch instead of upstream
  18 p,preserve-merges! try to recreate merges instead of ignoring them
  19 s,strategy=!       use the given merge strategy
  20 no-ff!             cherry-pick all commits, even if unchanged
  21 m,merge!           use merging strategies to rebase
  22 i,interactive!     let the user edit the list of commits to rebase
  23 x,exec=!           add exec lines after each commit of the editable list
  24 k,keep-empty       preserve empty commits during rebase
  25 f,force-rebase!    force rebase even if branch is up to date
  26 X,strategy-option=! pass the argument through to the merge strategy
  27 stat!              display a diffstat of what changed upstream
  28 n,no-stat!         do not show diffstat of what changed upstream
  29 verify             allow pre-rebase hook to run
  30 rerere-autoupdate  allow rerere to update index with resolved conflicts
  31 root!              rebase all reachable commits up to the root(s)
  32 autosquash         move commits that begin with squash!/fixup! under -i
  33 committer-date-is-author-date! passed to 'git am'
  34 ignore-date!       passed to 'git am'
  35 whitespace=!       passed to 'git apply'
  36 ignore-whitespace! passed to 'git apply'
  37 C=!                passed to 'git apply'
  38  Actions:
  39 continue!          continue
  40 abort!             abort and check out the original branch
  41 skip!              skip current patch and continue
  42 edit-todo!         edit the todo list during an interactive rebase
  43 "
  44 . git-sh-setup
  45 . git-sh-i18n
  46 set_reflog_action rebase
  47 require_work_tree_exists
  48 cd_to_toplevel
  49
  50 LF='
  51 '
  52 ok_to_skip_pre_rebase=
  53 resolvemsg="
  54 $(gettext 'When you have resolved this problem, run "git rebase --continue".
  55 If you prefer to skip this patch, run "git rebase --skip" instead.
  56 To check out the original branch and stop rebasing, run "git rebase --abort".')
  57 "
  58 unset onto
  59 cmd=
  60 strategy=
  61 strategy_opts=
  62 do_merge=
  63 merge_dir="$GIT_DIR"/rebase-merge
  64 apply_dir="$GIT_DIR"/rebase-apply
  65 verbose=
  66 diffstat=
  67 test "$(git config --bool rebase.stat)" = true && diffstat=t
  68 autostash="$(git config --bool rebase.autostash || echo false)"
  69 git_am_opt=
  70 rebase_root=
  71 force_rebase=
  72 allow_rerere_autoupdate=
  73 # Non-empty if a rebase was in progress when 'git rebase' was invoked
  74 in_progress=
  75 # One of {am, merge, interactive}
  76 type=
  77 # One of {"$GIT_DIR"/rebase-apply, "$GIT_DIR"/rebase-merge}
  78 state_dir=
  79 # One of {'', continue, skip, abort}, as parsed from command line
  80 action=
  81 preserve_merges=
  82 autosquash=
  83 keep_empty=
  84 test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
  85
  86 read_basic_state () {
  87         head_name=$(cat "$state_dir"/head-name) &&
  88         onto=$(cat "$state_dir"/onto) &&
  89         # We always write to orig-head, but interactive rebase used to write to
  90         # head. Fall back to reading from head to cover for the case that the
  91         # user upgraded git with an ongoing interactive rebase.
  92         if test -f "$state_dir"/orig-head
  93         then
  94                 orig_head=$(cat "$state_dir"/orig-head)
  95         else
  96                 orig_head=$(cat "$state_dir"/head)
  97         fi &&
  98         GIT_QUIET=$(cat "$state_dir"/quiet) &&
  99         test -f "$state_dir"/verbose && verbose=t
 100         test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
 101         test -f "$state_dir"/strategy_opts &&
 102                 strategy_opts="$(cat "$state_dir"/strategy_opts)"
 103         test -f "$state_dir"/allow_rerere_autoupdate &&
 104                 allow_rerere_autoupdate="$(cat "$state_dir"/allow_rerere_autoupdate)"
 105 }
 106
 107 write_basic_state () {
 108         echo "$head_name" > "$state_dir"/head-name &&
 109         echo "$onto" > "$state_dir"/onto &&
 110         echo "$orig_head" > "$state_dir"/orig-head &&
 111         echo "$GIT_QUIET" > "$state_dir"/quiet &&
 112         test t = "$verbose" && : > "$state_dir"/verbose
 113         test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
 114         test -n "$strategy_opts" && echo "$strategy_opts" > \
 115                 "$state_dir"/strategy_opts
 116         test -n "$allow_rerere_autoupdate" && echo "$allow_rerere_autoupdate" > \
 117                 "$state_dir"/allow_rerere_autoupdate
 118 }
 119
 120 output () {
 121         case "$verbose" in
 122         '')
 123                 output=$("$@" 2>&1 )
 124                 status=$?
 125                 test $status != 0 && printf "%s\n" "$output"
 126                 return $status
 127                 ;;
 128         *)
 129                 "$@"
 130                 ;;
 131         esac
 132 }
 133
 134 move_to_original_branch () {
 135         case "$head_name" in
 136         refs/*)
 137                 message="rebase finished: $head_name onto $onto"
 138                 git update-ref -m "$message" \
 139                         $head_name $(git rev-parse HEAD) $orig_head &&
 140                 git symbolic-ref \
 141                         -m "rebase finished: returning to $head_name" \
 142                         HEAD $head_name ||
 143                 die "$(gettext "Could not move back to $head_name")"
 144                 ;;
 145         esac
 146 }
 147
 148 finish_rebase () {
 149         if test -f "$state_dir/autostash"
 150         then
 151                 stash_sha1=$(cat "$state_dir/autostash")
 152                 if git stash apply $stash_sha1 2>&1 >/dev/null
 153                 then
 154                         echo "$(gettext 'Applied autostash.')"
 155                 else
 156                         ref_stash=refs/stash &&
 157                         >>"$GIT_DIR/logs/$ref_stash" &&
 158                         git update-ref -m "autostash" $ref_stash $stash_sha1 ||
 159                         die "$(eval_gettext 'Cannot store $stash_sha1')"
 160
 161                         gettext 'Applying autostash resulted in conflicts.
 162 Your changes are safe in the stash.
 163 You can run "git stash pop" or "git stash drop" it at any time.
 164 '
 165                 fi
 166         fi
 167         git gc --auto &&
 168         rm -rf "$state_dir"
 169 }
 170
 171 run_specific_rebase () {
 172         if [ "$interactive_rebase" = implied ]; then
 173                 GIT_EDITOR=:
 174                 export GIT_EDITOR
 175                 autosquash=
 176         fi
 177         . git-rebase--$type
 178         ret=$?
 179         if test $ret -eq 0
 180         then
 181                 finish_rebase
 182         fi
 183         exit $ret
 184 }
 185
 186 run_pre_rebase_hook () {
 187         if test -z "$ok_to_skip_pre_rebase" &&
 188            test -x "$GIT_DIR/hooks/pre-rebase"
 189         then
 190                 "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} ||
 191                 die "$(gettext "The pre-rebase hook refused to rebase.")"
 192         fi
 193 }
 194
 195 test -f "$apply_dir"/applying &&
 196         die "$(gettext "It looks like git-am is in progress. Cannot rebase.")"
 197
 198 if test -d "$apply_dir"
 199 then
 200         type=am
 201         state_dir="$apply_dir"
 202 elif test -d "$merge_dir"
 203 then
 204         if test -f "$merge_dir"/interactive
 205         then
 206                 type=interactive
 207                 interactive_rebase=explicit
 208         else
 209                 type=merge
 210         fi
 211         state_dir="$merge_dir"
 212 fi
 213 test -n "$type" && in_progress=t
 214
 215 total_argc=$#
 216 while test $# != 0
 217 do
 218         case "$1" in
 219         --no-verify)
 220                 ok_to_skip_pre_rebase=yes
 221                 ;;
 222         --verify)
 223                 ok_to_skip_pre_rebase=
 224                 ;;
 225         --continue|--skip|--abort|--edit-todo)
 226                 test $total_argc -eq 2 || usage
 227                 action=${1##--}
 228                 ;;
 229         --onto)
 230                 test 2 -le "$#" || usage
 231                 onto="$2"
 232                 shift
 233                 ;;
 234         -x)
 235                 test 2 -le "$#" || usage
 236                 cmd="${cmd}exec $2${LF}"
 237                 shift
 238                 ;;
 239         -i)
 240                 interactive_rebase=explicit
 241                 ;;
 242         -k)
 243                 keep_empty=yes
 244                 ;;
 245         -p)
 246                 preserve_merges=t
 247                 test -z "$interactive_rebase" && interactive_rebase=implied
 248                 ;;
 249         --autosquash)
 250                 autosquash=t
 251                 ;;
 252         --no-autosquash)
 253                 autosquash=
 254                 ;;
 255         -M|-m)
 256                 do_merge=t
 257                 ;;
 258         -X)
 259                 shift
 260                 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--$1")"
 261                 do_merge=t
 262                 test -z "$strategy" && strategy=recursive
 263                 ;;
 264         -s)
 265                 shift
 266                 strategy="$1"
 267                 do_merge=t
 268                 ;;
 269         -n)
 270                 diffstat=
 271                 ;;
 272         --stat)
 273                 diffstat=t
 274                 ;;
 275         --autostash)
 276                 autostash=true
 277                 ;;
 278         -v)
 279                 verbose=t
 280                 diffstat=t
 281                 GIT_QUIET=
 282                 ;;
 283         -q)
 284                 GIT_QUIET=t
 285                 git_am_opt="$git_am_opt -q"
 286                 verbose=
 287                 diffstat=
 288                 ;;
 289         --whitespace)
 290                 shift
 291                 git_am_opt="$git_am_opt --whitespace=$1"
 292                 case "$1" in
 293                 fix|strip)
 294                         force_rebase=t
 295                         ;;
 296                 esac
 297                 ;;
 298         --ignore-whitespace)
 299                 git_am_opt="$git_am_opt $1"
 300                 ;;
 301         --committer-date-is-author-date|--ignore-date)
 302                 git_am_opt="$git_am_opt $1"
 303                 force_rebase=t
 304                 ;;
 305         -C)
 306                 shift
 307                 git_am_opt="$git_am_opt -C$1"
 308                 ;;
 309         --root)
 310                 rebase_root=t
 311                 ;;
 312         -f|--no-ff)
 313                 force_rebase=t
 314                 ;;
 315         --rerere-autoupdate|--no-rerere-autoupdate)
 316                 allow_rerere_autoupdate="$1"
 317                 ;;
 318         --)
 319                 shift
 320                 break
 321                 ;;
 322         esac
 323         shift
 324 done
 325 test $# -gt 2 && usage
 326
 327 if test -n "$cmd" &&
 328    test "$interactive_rebase" != explicit
 329 then
 330         die "$(gettext "The --exec option must be used with the --interactive option")"
 331 fi
 332
 333 if test -n "$action"
 334 then
 335         test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
 336         # Only interactive rebase uses detailed reflog messages
 337         if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
 338         then
 339                 GIT_REFLOG_ACTION="rebase -i ($action)"
 340                 export GIT_REFLOG_ACTION
 341         fi
 342 fi
 343
 344 if test "$action" = "edit-todo" && test "$type" != "interactive"
 345 then
 346         die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
 347 fi
 348
 349 case "$action" in
 350 continue)
 351         # Sanity check
 352         git rev-parse --verify HEAD >/dev/null ||
 353                 die "$(gettext "Cannot read HEAD")"
 354         git update-index --ignore-submodules --refresh &&
 355         git diff-files --quiet --ignore-submodules || {
 356                 echo "$(gettext "You must edit all merge conflicts and then
 357 mark them as resolved using git add")"
 358                 exit 1
 359         }
 360         read_basic_state
 361         run_specific_rebase
 362         ;;
 363 skip)
 364         output git reset --hard HEAD || exit $?
 365         read_basic_state
 366         run_specific_rebase
 367         ;;
 368 abort)
 369         git rerere clear
 370         read_basic_state
 371         case "$head_name" in
 372         refs/*)
 373                 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
 374                 die "$(eval_gettext "Could not move back to \$head_name")"
 375                 ;;
 376         esac
 377         output git reset --hard $orig_head
 378         finish_rebase
 379         exit
 380         ;;
 381 edit-todo)
 382         run_specific_rebase
 383         ;;
 384 esac
 385
 386 # Make sure no rebase is in progress
 387 if test -n "$in_progress"
 388 then
 389         state_dir_base=${state_dir##*/}
 390         cmd_live_rebase="git rebase (--continue | --abort | --skip)"
 391         cmd_clear_stale_rebase="rm -fr \"$state_dir\""
 392         die "
 393 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
 394 I wonder if you are in the middle of another rebase.  If that is the
 395 case, please try
 396         $cmd_live_rebase
 397 If that is not the case, please
 398         $cmd_clear_stale_rebase
 399 and run me again.  I am stopping in case you still have something
 400 valuable there.')"
 401 fi
 402
 403 if test -n "$rebase_root" && test -z "$onto"
 404 then
 405         test -z "$interactive_rebase" && interactive_rebase=implied
 406 fi
 407
 408 if test -n "$interactive_rebase"
 409 then
 410         type=interactive
 411         state_dir="$merge_dir"
 412 elif test -n "$do_merge"
 413 then
 414         type=merge
 415         state_dir="$merge_dir"
 416 else
 417         type=am
 418         state_dir="$apply_dir"
 419 fi
 420
 421 if test -z "$rebase_root"
 422 then
 423         case "$#" in
 424         0)
 425                 if ! upstream_name=$(git rev-parse --symbolic-full-name \
 426                         --verify -q @{upstream} 2>/dev/null)
 427                 then
 428                         . git-parse-remote
 429                         error_on_missing_default_upstream "rebase" "rebase" \
 430                                 "against" "git rebase <branch>"
 431                 fi
 432                 ;;
 433         *)      upstream_name="$1"
 434                 shift
 435                 ;;
 436         esac
 437         upstream=`git rev-parse --verify "${upstream_name}^0"` ||
 438         die "$(eval_gettext "invalid upstream \$upstream_name")"
 439         upstream_arg="$upstream_name"
 440 else
 441         if test -z "$onto"
 442         then
 443                 empty_tree=`git hash-object -t tree /dev/null`
 444                 onto=`git commit-tree $empty_tree </dev/null`
 445                 squash_onto="$onto"
 446         fi
 447         unset upstream_name
 448         unset upstream
 449         test $# -gt 1 && usage
 450         upstream_arg=--root
 451 fi
 452
 453 # Make sure the branch to rebase onto is valid.
 454 onto_name=${onto-"$upstream_name"}
 455 case "$onto_name" in
 456 *...*)
 457         if      left=${onto_name%...*} right=${onto_name#*...} &&
 458                 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
 459         then
 460                 case "$onto" in
 461                 ?*"$LF"?*)
 462                         die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
 463                         ;;
 464                 '')
 465                         die "$(eval_gettext "\$onto_name: there is no merge base")"
 466                         ;;
 467                 esac
 468         else
 469                 die "$(eval_gettext "\$onto_name: there is no merge base")"
 470         fi
 471         ;;
 472 *)
 473         onto=$(git rev-parse --verify "${onto_name}^0") ||
 474         die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
 475         ;;
 476 esac
 477
 478 # If the branch to rebase is given, that is the branch we will rebase
 479 # $branch_name -- branch being rebased, or HEAD (already detached)
 480 # $orig_head -- commit object name of tip of the branch before rebasing
 481 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
 482 switch_to=
 483 case "$#" in
 484 1)
 485         # Is it "rebase other $branchname" or "rebase other $commit"?
 486         branch_name="$1"
 487         switch_to="$1"
 488
 489         if git show-ref --verify --quiet -- "refs/heads/$1" &&
 490            orig_head=$(git rev-parse -q --verify "refs/heads/$1")
 491         then
 492                 head_name="refs/heads/$1"
 493         elif orig_head=$(git rev-parse -q --verify "$1")
 494         then
 495                 head_name="detached HEAD"
 496         else
 497                 die "$(eval_gettext "fatal: no such branch: \$branch_name")"
 498         fi
 499         ;;
 500 0)
 501         # Do not need to switch branches, we are already on it.
 502         if branch_name=`git symbolic-ref -q HEAD`
 503         then
 504                 head_name=$branch_name
 505                 branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
 506         else
 507                 head_name="detached HEAD"
 508                 branch_name=HEAD ;# detached
 509         fi
 510         orig_head=$(git rev-parse --verify HEAD) || exit
 511         ;;
 512 *)
 513         die "BUG: unexpected number of arguments left to parse"
 514         ;;
 515 esac
 516
 517 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
 518 then
 519         stash_sha1=$(git stash create "autostash") ||
 520         die "$(gettext 'Cannot autostash')"
 521
 522         mkdir -p "$state_dir" &&
 523         echo $stash_sha1 >"$state_dir/autostash" &&
 524         stash_abbrev=$(git rev-parse --short $stash_sha1) &&
 525         echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
 526         git reset --hard
 527 fi
 528
 529 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
 530
 531 # Now we are rebasing commits $upstream..$orig_head (or with --root,
 532 # everything leading up to $orig_head) on top of $onto
 533
 534 # Check if we are already based on $onto with linear history,
 535 # but this should be done only when upstream and onto are the same
 536 # and if this is not an interactive rebase.
 537 mb=$(git merge-base "$onto" "$orig_head")
 538 if test "$type" != interactive && test "$upstream" = "$onto" &&
 539         test "$mb" = "$onto" &&
 540         # linear history?
 541         ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
 542 then
 543         if test -z "$force_rebase"
 544         then
 545                 # Lazily switch to the target branch if needed...
 546                 test -z "$switch_to" || git checkout "$switch_to" --
 547                 say "$(eval_gettext "Current branch \$branch_name is up to date.")"
 548                 exit 0
 549         else
 550                 say "$(eval_gettext "Current branch \$branch_name is up to date, rebase forced.")"
 551         fi
 552 fi
 553
 554 # If a hook exists, give it a chance to interrupt
 555 run_pre_rebase_hook "$upstream_arg" "$@"
 556
 557 if test -n "$diffstat"
 558 then
 559         if test -n "$verbose"
 560         then
 561                 echo "$(eval_gettext "Changes from \$mb to \$onto:")"
 562         fi
 563         # We want color (if set), but no pager
 564         GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
 565 fi
 566
 567 test "$type" = interactive && run_specific_rebase
 568
 569 # Detach HEAD and reset the tree
 570 say "$(gettext "First, rewinding head to replay your work on top of it...")"
 571 git checkout -q "$onto^0" || die "could not detach HEAD"
 572 git update-ref ORIG_HEAD $orig_head
 573
 574 # If the $onto is a proper descendant of the tip of the branch, then
 575 # we just fast-forwarded.
 576 if test "$mb" = "$orig_head"
 577 then
 578         say "$(eval_gettext "Fast-forwarded \$branch_name to \$onto_name.")"
 579         move_to_original_branch
 580         exit 0
 581 fi
 582
 583 if test -n "$rebase_root"
 584 then
 585         revisions="$onto..$orig_head"
 586 else
 587         revisions="$upstream..$orig_head"
 588 fi
 589
 590 run_specific_rebase