git-rebase.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2005 Junio C Hamano.
   4 #
   5
   6 USAGE='[-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 .dotest working files, use the command
  18 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.  You must be in the top
  22 directory of your project to start (or continue) a rebase.
  23
  24 Example:       git-rebase master~1 topic
  25
  26         A---B---C topic                   A'\''--B'\''--C'\'' topic
  27        /                   -->           /
  28   D---E---F---G master          D---E---F---G master
  29 '
  30 . git-sh-setup
  31 set_reflog_action rebase
  32 require_work_tree
  33
  34 RESOLVEMSG="
  35 When you have resolved this problem run \"git rebase --continue\".
  36 If you would prefer to skip this patch, instead run \"git rebase --skip\".
  37 To restore the original branch and stop rebasing run \"git rebase --abort\".
  38 "
  39 unset newbase
  40 strategy=recursive
  41 do_merge=
  42 dotest=$GIT_DIR/.dotest-merge
  43 prec=4
  44 verbose=
  45
  46 continue_merge () {
  47         test -n "$prev_head" || die "prev_head must be defined"
  48         test -d "$dotest" || die "$dotest directory does not exist"
  49
  50         unmerged=$(git-ls-files -u)
  51         if test -n "$unmerged"
  52         then
  53                 echo "You still have unmerged paths in your index"
  54                 echo "did you forget update-index?"
  55                 die "$RESOLVEMSG"
  56         fi
  57
  58         if test -n "`git-diff-index HEAD`"
  59         then
  60                 if ! git-commit -C "`cat $dotest/current`"
  61                 then
  62                         echo "Commit failed, please do not call \"git commit\""
  63                         echo "directly, but instead do one of the following: "
  64                         die "$RESOLVEMSG"
  65                 fi
  66                 printf "Committed: %0${prec}d" $msgnum
  67         else
  68                 printf "Already applied: %0${prec}d" $msgnum
  69         fi
  70         echo ' '`git-rev-list --pretty=oneline -1 HEAD | \
  71                                 sed 's/^[a-f0-9]\+ //'`
  72
  73         prev_head=`git-rev-parse HEAD^0`
  74         # save the resulting commit so we can read-tree on it later
  75         echo "$prev_head" > "$dotest/prev_head"
  76
  77         # onto the next patch:
  78         msgnum=$(($msgnum + 1))
  79         echo "$msgnum" >"$dotest/msgnum"
  80 }
  81
  82 call_merge () {
  83         cmt="$(cat $dotest/cmt.$1)"
  84         echo "$cmt" > "$dotest/current"
  85         hd=$(git-rev-parse --verify HEAD)
  86         cmt_name=$(git-symbolic-ref HEAD)
  87         msgnum=$(cat $dotest/msgnum)
  88         end=$(cat $dotest/end)
  89         eval GITHEAD_$cmt='"${cmt_name##refs/heads/}~$(($end - $msgnum))"'
  90         eval GITHEAD_$hd='"$(cat $dotest/onto_name)"'
  91         export GITHEAD_$cmt GITHEAD_$hd
  92         git-merge-$strategy "$cmt^" -- "$hd" "$cmt"
  93         rv=$?
  94         case "$rv" in
  95         0)
  96                 unset GITHEAD_$cmt GITHEAD_$hd
  97                 return
  98                 ;;
  99         1)
 100                 test -d "$GIT_DIR/rr-cache" && git-rerere
 101                 die "$RESOLVEMSG"
 102                 ;;
 103         2)
 104                 echo "Strategy: $rv $strategy failed, try another" 1>&2
 105                 die "$RESOLVEMSG"
 106                 ;;
 107         *)
 108                 die "Unknown exit code ($rv) from command:" \
 109                         "git-merge-$strategy $cmt^ -- HEAD $cmt"
 110                 ;;
 111         esac
 112 }
 113
 114 finish_rb_merge () {
 115         rm -r "$dotest"
 116         echo "All done."
 117 }
 118
 119 while case "$#" in 0) break ;; esac
 120 do
 121         case "$1" in
 122         --continue)
 123                 diff=$(git-diff-files)
 124                 case "$diff" in
 125                 ?*)     echo "You must edit all merge conflicts and then"
 126                         echo "mark them as resolved using git update-index"
 127                         exit 1
 128                         ;;
 129                 esac
 130                 if test -d "$dotest"
 131                 then
 132                         prev_head="`cat $dotest/prev_head`"
 133                         end="`cat $dotest/end`"
 134                         msgnum="`cat $dotest/msgnum`"
 135                         onto="`cat $dotest/onto`"
 136                         continue_merge
 137                         while test "$msgnum" -le "$end"
 138                         do
 139                                 call_merge "$msgnum"
 140                                 continue_merge
 141                         done
 142                         finish_rb_merge
 143                         exit
 144                 fi
 145                 git am --resolved --3way --resolvemsg="$RESOLVEMSG"
 146                 exit
 147                 ;;
 148         --skip)
 149                 if test -d "$dotest"
 150                 then
 151                         if test -d "$GIT_DIR/rr-cache"
 152                         then
 153                                 git-rerere clear
 154                         fi
 155                         prev_head="`cat $dotest/prev_head`"
 156                         end="`cat $dotest/end`"
 157                         msgnum="`cat $dotest/msgnum`"
 158                         msgnum=$(($msgnum + 1))
 159                         onto="`cat $dotest/onto`"
 160                         while test "$msgnum" -le "$end"
 161                         do
 162                                 call_merge "$msgnum"
 163                                 continue_merge
 164                         done
 165                         finish_rb_merge
 166                         exit
 167                 fi
 168                 git am -3 --skip --resolvemsg="$RESOLVEMSG"
 169                 exit
 170                 ;;
 171         --abort)
 172                 if test -d "$GIT_DIR/rr-cache"
 173                 then
 174                         git-rerere clear
 175                 fi
 176                 if test -d "$dotest"
 177                 then
 178                         rm -r "$dotest"
 179                 elif test -d .dotest
 180                 then
 181                         rm -r .dotest
 182                 else
 183                         die "No rebase in progress?"
 184                 fi
 185                 git reset --hard ORIG_HEAD
 186                 exit
 187                 ;;
 188         --onto)
 189                 test 2 -le "$#" || usage
 190                 newbase="$2"
 191                 shift
 192                 ;;
 193         -M|-m|--m|--me|--mer|--merg|--merge)
 194                 do_merge=t
 195                 ;;
 196         -s=*|--s=*|--st=*|--str=*|--stra=*|--strat=*|--strate=*|\
 197                 --strateg=*|--strategy=*|\
 198         -s|--s|--st|--str|--stra|--strat|--strate|--strateg|--strategy)
 199                 case "$#,$1" in
 200                 *,*=*)
 201                         strategy=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
 202                 1,*)
 203                         usage ;;
 204                 *)
 205                         strategy="$2"
 206                         shift ;;
 207                 esac
 208                 do_merge=t
 209                 ;;
 210         -v|--verbose)
 211                 verbose=t
 212                 ;;
 213         -*)
 214                 usage
 215                 ;;
 216         *)
 217                 break
 218                 ;;
 219         esac
 220         shift
 221 done
 222
 223 # Make sure we do not have .dotest
 224 if test -z "$do_merge"
 225 then
 226         if mkdir .dotest
 227         then
 228                 rmdir .dotest
 229         else
 230                 echo >&2 '
 231 It seems that I cannot create a .dotest directory, and I wonder if you
 232 are in the middle of patch application or another rebase.  If that is not
 233 the case, please rm -fr .dotest and run me again.  I am stopping in case
 234 you still have something valuable there.'
 235                 exit 1
 236         fi
 237 else
 238         if test -d "$dotest"
 239         then
 240                 die "previous dotest directory $dotest still exists." \
 241                         'try git-rebase < --continue | --abort >'
 242         fi
 243 fi
 244
 245 # The tree must be really really clean.
 246 git-update-index --refresh || exit
 247 diff=$(git-diff-index --cached --name-status -r HEAD)
 248 case "$diff" in
 249 ?*)     echo "$diff"
 250         exit 1
 251         ;;
 252 esac
 253
 254 # The upstream head must be given.  Make sure it is valid.
 255 upstream_name="$1"
 256 upstream=`git rev-parse --verify "${upstream_name}^0"` ||
 257     die "invalid upstream $upstream_name"
 258
 259 # If a hook exists, give it a chance to interrupt
 260 if test -x "$GIT_DIR/hooks/pre-rebase"
 261 then
 262         "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} || {
 263                 echo >&2 "The pre-rebase hook refused to rebase."
 264                 exit 1
 265         }
 266 fi
 267
 268 # If the branch to rebase is given, first switch to it.
 269 case "$#" in
 270 2)
 271         branch_name="$2"
 272         git-checkout "$2" || usage
 273         ;;
 274 *)
 275         branch_name=`git symbolic-ref HEAD` || die "No current branch"
 276         branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
 277         ;;
 278 esac
 279 branch=$(git-rev-parse --verify "${branch_name}^0") || exit
 280
 281 # Make sure the branch to rebase onto is valid.
 282 onto_name=${newbase-"$upstream_name"}
 283 onto=$(git-rev-parse --verify "${onto_name}^0") || exit
 284
 285 # Now we are rebasing commits $upstream..$branch on top of $onto
 286
 287 # Check if we are already based on $onto, but this should be
 288 # done only when upstream and onto are the same.
 289 mb=$(git-merge-base "$onto" "$branch")
 290 if test "$upstream" = "$onto" && test "$mb" = "$onto"
 291 then
 292         echo >&2 "Current branch $branch_name is up to date."
 293         exit 0
 294 fi
 295
 296 if test -n "$verbose"
 297 then
 298         echo "Changes from $mb to $onto:"
 299         git-diff-tree --stat --summary "$mb" "$onto"
 300 fi
 301
 302 # Rewind the head to "$onto"; this saves our current head in ORIG_HEAD.
 303 echo "First, rewinding head to replay your work on top of it..."
 304 git-reset --hard "$onto"
 305
 306 # If the $onto is a proper descendant of the tip of the branch, then
 307 # we just fast forwarded.
 308 if test "$mb" = "$branch"
 309 then
 310         echo >&2 "Fast-forwarded $branch_name to $onto_name."
 311         exit 0
 312 fi
 313
 314 if test -z "$do_merge"
 315 then
 316         git-format-patch -k --stdout --full-index --ignore-if-in-upstream "$upstream"..ORIG_HEAD |
 317         git am --binary -3 -k --resolvemsg="$RESOLVEMSG"
 318         exit $?
 319 fi
 320
 321 # start doing a rebase with git-merge
 322 # this is rename-aware if the recursive (default) strategy is used
 323
 324 mkdir -p "$dotest"
 325 echo "$onto" > "$dotest/onto"
 326 echo "$onto_name" > "$dotest/onto_name"
 327 prev_head=`git-rev-parse HEAD^0`
 328 echo "$prev_head" > "$dotest/prev_head"
 329
 330 msgnum=0
 331 for cmt in `git-rev-list --no-merges "$upstream"..ORIG_HEAD \
 332                         | @@PERL@@ -e 'print reverse <>'`
 333 do
 334         msgnum=$(($msgnum + 1))
 335         echo "$cmt" > "$dotest/cmt.$msgnum"
 336 done
 337
 338 echo 1 >"$dotest/msgnum"
 339 echo $msgnum >"$dotest/end"
 340
 341 end=$msgnum
 342 msgnum=1
 343
 344 while test "$msgnum" -le "$end"
 345 do
 346         call_merge "$msgnum"
 347         continue_merge
 348 done
 349
 350 finish_rb_merge