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         test -f "$state_dir/head-name" &&
  88         test -f "$state_dir/onto" &&
  89         head_name=$(cat "$state_dir"/head-name) &&
  90         onto=$(cat "$state_dir"/onto) &&
  91         # We always write to orig-head, but interactive rebase used to write to
  92         # head. Fall back to reading from head to cover for the case that the
  93         # user upgraded git with an ongoing interactive rebase.
  94         if test -f "$state_dir"/orig-head
  95         then
  96                 orig_head=$(cat "$state_dir"/orig-head)
  97         else
  98                 orig_head=$(cat "$state_dir"/head)
  99         fi &&
 100         GIT_QUIET=$(cat "$state_dir"/quiet) &&
 101         test -f "$state_dir"/verbose && verbose=t
 102         test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
 103         test -f "$state_dir"/strategy_opts &&
 104                 strategy_opts="$(cat "$state_dir"/strategy_opts)"
 105         test -f "$state_dir"/allow_rerere_autoupdate &&
 106                 allow_rerere_autoupdate="$(cat "$state_dir"/allow_rerere_autoupdate)"
 107 }
 108
 109 write_basic_state () {
 110         echo "$head_name" > "$state_dir"/head-name &&
 111         echo "$onto" > "$state_dir"/onto &&
 112         echo "$orig_head" > "$state_dir"/orig-head &&
 113         echo "$GIT_QUIET" > "$state_dir"/quiet &&
 114         test t = "$verbose" && : > "$state_dir"/verbose
 115         test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
 116         test -n "$strategy_opts" && echo "$strategy_opts" > \
 117                 "$state_dir"/strategy_opts
 118         test -n "$allow_rerere_autoupdate" && echo "$allow_rerere_autoupdate" > \
 119                 "$state_dir"/allow_rerere_autoupdate
 120 }
 121
 122 output () {
 123         case "$verbose" in
 124         '')
 125                 output=$("$@" 2>&1 )
 126                 status=$?
 127                 test $status != 0 && printf "%s\n" "$output"
 128                 return $status
 129                 ;;
 130         *)
 131                 "$@"
 132                 ;;
 133         esac
 134 }
 135
 136 move_to_original_branch () {
 137         case "$head_name" in
 138         refs/*)
 139                 message="rebase finished: $head_name onto $onto"
 140                 git update-ref -m "$message" \
 141                         $head_name $(git rev-parse HEAD) $orig_head &&
 142                 git symbolic-ref \
 143                         -m "rebase finished: returning to $head_name" \
 144                         HEAD $head_name ||
 145                 die "$(gettext "Could not move back to $head_name")"
 146                 ;;
 147         esac
 148 }
 149
 150 finish_rebase () {
 151         if test -f "$state_dir/autostash"
 152         then
 153                 stash_sha1=$(cat "$state_dir/autostash")
 154                 if git stash apply $stash_sha1 2>&1 >/dev/null
 155                 then
 156                         echo "$(gettext 'Applied autostash.')"
 157                 else
 158                         git stash store -m "autostash" -q $stash_sha1 ||
 159                         die "$(eval_gettext "Cannot store \$stash_sha1")"
 160                         gettext 'Applying autostash resulted in conflicts.
 161 Your changes are safe in the stash.
 162 You can run "git stash pop" or "git stash drop" it at any time.
 163 '
 164                 fi
 165         fi
 166         git gc --auto &&
 167         rm -rf "$state_dir"
 168 }
 169
 170 run_specific_rebase () {
 171         if [ "$interactive_rebase" = implied ]; then
 172                 GIT_EDITOR=:
 173                 export GIT_EDITOR
 174                 autosquash=
 175         fi
 176         . git-rebase--$type
 177         ret=$?
 178         if test $ret -eq 0
 179         then
 180                 finish_rebase
 181         fi
 182         exit $ret
 183 }
 184
 185 run_pre_rebase_hook () {
 186         if test -z "$ok_to_skip_pre_rebase" &&
 187            test -x "$GIT_DIR/hooks/pre-rebase"
 188         then
 189                 "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} ||
 190                 die "$(gettext "The pre-rebase hook refused to rebase.")"
 191         fi
 192 }
 193
 194 test -f "$apply_dir"/applying &&
 195         die "$(gettext "It looks like git-am is in progress. Cannot rebase.")"
 196
 197 if test -d "$apply_dir"
 198 then
 199         type=am
 200         state_dir="$apply_dir"
 201 elif test -d "$merge_dir"
 202 then
 203         if test -f "$merge_dir"/interactive
 204         then
 205                 type=interactive
 206                 interactive_rebase=explicit
 207         else
 208                 type=merge
 209         fi
 210         state_dir="$merge_dir"
 211 fi
 212 test -n "$type" && in_progress=t
 213
 214 total_argc=$#
 215 while test $# != 0
 216 do
 217         case "$1" in
 218         --no-verify)
 219                 ok_to_skip_pre_rebase=yes
 220                 ;;
 221         --verify)
 222                 ok_to_skip_pre_rebase=
 223                 ;;
 224         --continue|--skip|--abort|--edit-todo)
 225                 test $total_argc -eq 2 || usage
 226                 action=${1##--}
 227                 ;;
 228         --onto)
 229                 test 2 -le "$#" || usage
 230                 onto="$2"
 231                 shift
 232                 ;;
 233         -x)
 234                 test 2 -le "$#" || usage
 235                 cmd="${cmd}exec $2${LF}"
 236                 shift
 237                 ;;
 238         -i)
 239                 interactive_rebase=explicit
 240                 ;;
 241         -k)
 242                 keep_empty=yes
 243                 ;;
 244         -p)
 245                 preserve_merges=t
 246                 test -z "$interactive_rebase" && interactive_rebase=implied
 247                 ;;
 248         --autosquash)
 249                 autosquash=t
 250                 ;;
 251         --no-autosquash)
 252                 autosquash=
 253                 ;;
 254         -M|-m)
 255                 do_merge=t
 256                 ;;
 257         -X)
 258                 shift
 259                 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--$1")"
 260                 do_merge=t
 261                 test -z "$strategy" && strategy=recursive
 262                 ;;
 263         -s)
 264                 shift
 265                 strategy="$1"
 266                 do_merge=t
 267                 ;;
 268         -n)
 269                 diffstat=
 270                 ;;
 271         --stat)
 272                 diffstat=t
 273                 ;;
 274         --autostash)
 275                 autostash=true
 276                 ;;
 277         -v)
 278                 verbose=t
 279                 diffstat=t
 280                 GIT_QUIET=
 281                 ;;
 282         -q)
 283                 GIT_QUIET=t
 284                 git_am_opt="$git_am_opt -q"
 285                 verbose=
 286                 diffstat=
 287                 ;;
 288         --whitespace)
 289                 shift
 290                 git_am_opt="$git_am_opt --whitespace=$1"
 291                 case "$1" in
 292                 fix|strip)
 293                         force_rebase=t
 294                         ;;
 295                 esac
 296                 ;;
 297         --ignore-whitespace)
 298                 git_am_opt="$git_am_opt $1"
 299                 ;;
 300         --committer-date-is-author-date|--ignore-date)
 301                 git_am_opt="$git_am_opt $1"
 302                 force_rebase=t
 303                 ;;
 304         -C)
 305                 shift
 306                 git_am_opt="$git_am_opt -C$1"
 307                 ;;
 308         --root)
 309                 rebase_root=t
 310                 ;;
 311         -f|--no-ff)
 312                 force_rebase=t
 313                 ;;
 314         --rerere-autoupdate|--no-rerere-autoupdate)
 315                 allow_rerere_autoupdate="$1"
 316                 ;;
 317         --)
 318                 shift
 319                 break
 320                 ;;
 321         esac
 322         shift
 323 done
 324 test $# -gt 2 && usage
 325
 326 if test -n "$cmd" &&
 327    test "$interactive_rebase" != explicit
 328 then
 329         die "$(gettext "The --exec option must be used with the --interactive option")"
 330 fi
 331
 332 if test -n "$action"
 333 then
 334         test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
 335         # Only interactive rebase uses detailed reflog messages
 336         if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
 337         then
 338                 GIT_REFLOG_ACTION="rebase -i ($action)"
 339                 export GIT_REFLOG_ACTION
 340         fi
 341 fi
 342
 343 if test "$action" = "edit-todo" && test "$type" != "interactive"
 344 then
 345         die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
 346 fi
 347
 348 case "$action" in
 349 continue)
 350         # Sanity check
 351         git rev-parse --verify HEAD >/dev/null ||
 352                 die "$(gettext "Cannot read HEAD")"
 353         git update-index --ignore-submodules --refresh &&
 354         git diff-files --quiet --ignore-submodules || {
 355                 echo "$(gettext "You must edit all merge conflicts and then
 356 mark them as resolved using git add")"
 357                 exit 1
 358         }
 359         read_basic_state
 360         run_specific_rebase
 361         ;;
 362 skip)
 363         output git reset --hard HEAD || exit $?
 364         read_basic_state
 365         run_specific_rebase
 366         ;;
 367 abort)
 368         git rerere clear
 369         read_basic_state
 370         case "$head_name" in
 371         refs/*)
 372                 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
 373                 die "$(eval_gettext "Could not move back to \$head_name")"
 374                 ;;
 375         esac
 376         output git reset --hard $orig_head
 377         finish_rebase
 378         exit
 379         ;;
 380 edit-todo)
 381         run_specific_rebase
 382         ;;
 383 esac
 384
 385 # Make sure no rebase is in progress
 386 if test -n "$in_progress"
 387 then
 388         state_dir_base=${state_dir##*/}
 389         cmd_live_rebase="git rebase (--continue | --abort | --skip)"
 390         cmd_clear_stale_rebase="rm -fr \"$state_dir\""
 391         die "
 392 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
 393 I wonder if you are in the middle of another rebase.  If that is the
 394 case, please try
 395         $cmd_live_rebase
 396 If that is not the case, please
 397         $cmd_clear_stale_rebase
 398 and run me again.  I am stopping in case you still have something
 399 valuable there.')"
 400 fi
 401
 402 if test -n "$rebase_root" && test -z "$onto"
 403 then
 404         test -z "$interactive_rebase" && interactive_rebase=implied
 405 fi
 406
 407 if test -n "$interactive_rebase"
 408 then
 409         type=interactive
 410         state_dir="$merge_dir"
 411 elif test -n "$do_merge"
 412 then
 413         type=merge
 414         state_dir="$merge_dir"
 415 else
 416         type=am
 417         state_dir="$apply_dir"
 418 fi
 419
 420 if test -z "$rebase_root"
 421 then
 422         case "$#" in
 423         0)
 424                 if ! upstream_name=$(git rev-parse --symbolic-full-name \
 425                         --verify -q @{upstream} 2>/dev/null)
 426                 then
 427                         . git-parse-remote
 428                         error_on_missing_default_upstream "rebase" "rebase" \
 429                                 "against" "git rebase <branch>"
 430                 fi
 431                 ;;
 432         *)      upstream_name="$1"
 433                 shift
 434                 ;;
 435         esac
 436         upstream=$(peel_committish "${upstream_name}") ||
 437         die "$(eval_gettext "invalid upstream \$upstream_name")"
 438         upstream_arg="$upstream_name"
 439 else
 440         if test -z "$onto"
 441         then
 442                 empty_tree=`git hash-object -t tree /dev/null`
 443                 onto=`git commit-tree $empty_tree </dev/null`
 444                 squash_onto="$onto"
 445         fi
 446         unset upstream_name
 447         unset upstream
 448         test $# -gt 1 && usage
 449         upstream_arg=--root
 450 fi
 451
 452 # Make sure the branch to rebase onto is valid.
 453 onto_name=${onto-"$upstream_name"}
 454 case "$onto_name" in
 455 *...*)
 456         if      left=${onto_name%...*} right=${onto_name#*...} &&
 457                 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
 458         then
 459                 case "$onto" in
 460                 ?*"$LF"?*)
 461                         die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
 462                         ;;
 463                 '')
 464                         die "$(eval_gettext "\$onto_name: there is no merge base")"
 465                         ;;
 466                 esac
 467         else
 468                 die "$(eval_gettext "\$onto_name: there is no merge base")"
 469         fi
 470         ;;
 471 *)
 472         onto=$(peel_committish "$onto_name") ||
 473         die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
 474         ;;
 475 esac
 476
 477 # If the branch to rebase is given, that is the branch we will rebase
 478 # $branch_name -- branch being rebased, or HEAD (already detached)
 479 # $orig_head -- commit object name of tip of the branch before rebasing
 480 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
 481 switch_to=
 482 case "$#" in
 483 1)
 484         # Is it "rebase other $branchname" or "rebase other $commit"?
 485         branch_name="$1"
 486         switch_to="$1"
 487
 488         if git show-ref --verify --quiet -- "refs/heads/$1" &&
 489            orig_head=$(git rev-parse -q --verify "refs/heads/$1")
 490         then
 491                 head_name="refs/heads/$1"
 492         elif orig_head=$(git rev-parse -q --verify "$1")
 493         then
 494                 head_name="detached HEAD"
 495         else
 496                 die "$(eval_gettext "fatal: no such branch: \$branch_name")"
 497         fi
 498         ;;
 499 0)
 500         # Do not need to switch branches, we are already on it.
 501         if branch_name=`git symbolic-ref -q HEAD`
 502         then
 503                 head_name=$branch_name
 504                 branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
 505         else
 506                 head_name="detached HEAD"
 507                 branch_name=HEAD ;# detached
 508         fi
 509         orig_head=$(git rev-parse --verify HEAD) || exit
 510         ;;
 511 *)
 512         die "BUG: unexpected number of arguments left to parse"
 513         ;;
 514 esac
 515
 516 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
 517 then
 518         stash_sha1=$(git stash create "autostash") ||
 519         die "$(gettext 'Cannot autostash')"
 520
 521         mkdir -p "$state_dir" &&
 522         echo $stash_sha1 >"$state_dir/autostash" &&
 523         stash_abbrev=$(git rev-parse --short $stash_sha1) &&
 524         echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
 525         git reset --hard
 526 fi
 527
 528 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
 529
 530 # Now we are rebasing commits $upstream..$orig_head (or with --root,
 531 # everything leading up to $orig_head) on top of $onto
 532
 533 # Check if we are already based on $onto with linear history,
 534 # but this should be done only when upstream and onto are the same
 535 # and if this is not an interactive rebase.
 536 mb=$(git merge-base "$onto" "$orig_head")
 537 if test "$type" != interactive && test "$upstream" = "$onto" &&
 538         test "$mb" = "$onto" &&
 539         # linear history?
 540         ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
 541 then
 542         if test -z "$force_rebase"
 543         then
 544                 # Lazily switch to the target branch if needed...
 545                 test -z "$switch_to" || git checkout "$switch_to" --
 546                 say "$(eval_gettext "Current branch \$branch_name is up to date.")"
 547                 finish_rebase
 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         finish_rebase
 581         exit 0
 582 fi
 583
 584 if test -n "$rebase_root"
 585 then
 586         revisions="$onto..$orig_head"
 587 else
 588         revisions="$upstream..$orig_head"
 589 fi
 590
 591 run_specific_rebase