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