share/msysGit/shears.sh

   1 #!/bin/sh
   2 #
   3 # Rebase the thicket of branches -- including their merge structure -- on top
   4 # of the specified upstream branch (defaults to 'junio/next'), optionally
   5 # retaining "fast-forwardability" by fake-merging (using the "ours" strategy)
   6 # the previous state on top of the current upstream state ("merging rebase").
   7 #
   8 # options:
   9 #  --merging
  10 #     start the rebased branch by a fake merge of the previous state
  11 #
  12 # The idea is to generate our very own rebase script, then call rebase -i with
  13 # our fake editor to put the rebase script into place and then let the user edit
  14 # the script.
  15 #
  16 # To make things prettier, we rewrite the rebase script after letting the user
  17 # edit it, to replace "new" rebase commands with calls to a temporary alias ".r"
  18 # that is added to help with starting the merging rebase, merging things, and
  19 # cleaning up afterwards.
  20
  21 die () {
  22         echo "$*" >&2
  23         exit 1
  24 }
  25
  26 git_dir="$(git rev-parse --git-dir)" ||
  27 die "Not in a Git directory"
  28
  29 help () {
  30         cat >&2 << EOF
  31 Usage: $0 [options] <upstream>
  32
  33 Options:
  34 -m|--merging[=<msg>]    allow fast-forwarding the current to the rebased branch
  35 --onto=<commit>         rebase onto the given commit
  36 --recreate=<merge>      recreate the branch merged in the specified commit
  37 EOF
  38         exit 1
  39 }
  40
  41 # Extra commands for use in the rebase script
  42 extra_commands="edit bud finish mark rewind merge start_merging_rebase cleanup"
  43
  44 edit () {
  45         GIT_EDITOR="$1" &&
  46         GIT_SEQUENCE_EDITOR="$GIT_EDITOR" &&
  47         export GIT_EDITOR GIT_SEQUENCE_EDITOR &&
  48         shift &&
  49         case "$*" in
  50         */git-rebase-todo)
  51                 sed -e '/^noop/d' < "$1" >> "$git_dir"/SHEARS-SCRIPT &&
  52                 mv "$git_dir"/SHEARS-SCRIPT "$1"
  53                 "$GIT_EDITOR" "$@" &&
  54                 mv "$1" "$git_dir"/SHEARS-SCRIPT &&
  55                 exprs="$(for command in $extra_commands
  56                         do
  57                                 printf " -e 's/^$command\$/exec git .r &/'"
  58                                 printf " -e 's/^$command /exec git .r &/'"
  59                         done)" &&
  60                 eval sed $exprs < "$git_dir"/SHEARS-SCRIPT > "$1"
  61                 ;;
  62         *)
  63                 exec "$GIT_EDITOR" "$@"
  64         esac
  65 }
  66
  67 mark () {
  68         git update-ref -m "Marking '$1' as rewritten" refs/rewritten/"$1" HEAD
  69 }
  70
  71 rewind () {
  72         git reset --hard refs/rewritten/"$1"
  73 }
  74
  75 bud () {
  76         shorthead="$(git rev-parse --short --verify HEAD)" &&
  77         git for-each-ref refs/rewritten/ |
  78         grep "^$shorthead" ||
  79         die "Refusing to leave unmarked revision $shorthead behind"
  80         git reset --hard refs/rewritten/onto
  81 }
  82
  83 finish () {
  84         mark "$@" &&
  85         bud
  86 }
  87
  88 merge () {
  89         # parse command-line arguments
  90         parents=
  91         while test $# -gt 0 && test "a$1" != a-C
  92         do
  93                 parents="$parents $1" &&
  94                 shift
  95         done &&
  96         if test "a$1" = "a-C"
  97         then
  98                 shift &&
  99                 orig="$1" &&
 100                 shift &&
 101                 # determine whether the merge needs to be redone
 102                 p="$(git rev-parse HEAD)$parents" &&
 103                 o="$(git rev-list -1 --parents $orig |
 104                         sed "s/[^ ]*//")" &&
 105                 while p=${p# }; o=${o# }; test -n "$p$o"
 106                 do
 107                         p1=${p%% *}; o1=${o%% *};
 108                         test $o1 = "$(git rev-parse "$p1")" || break
 109                         p=${p#$p1}; o=${o#$o1}
 110                 done &&
 111                 # either redo merge or fast-forward
 112                 if test -z "$p$o"
 113                 then
 114                         git reset --hard $orig
 115                         return
 116                 fi &&
 117                 msg="$(git cat-file commit $orig |
 118                         sed "1,/^$/d")"
 119         else
 120                 msg=
 121                 p=
 122                 for parent in $parents
 123                 do
 124                         test -z "$msg" ||
 125                         msg="$msg and "
 126                         msg="$msg'$parent'"
 127                         p="$p $(git rev-parse --verify refs/rewritten/$parent \
 128                                         2> /dev/null ||
 129                                 echo $parent)"
 130                 done &&
 131                 msg="Merge $msg into HEAD"
 132         fi &&
 133         git merge -n --no-ff -m "$msg" $p
 134 }
 135
 136 start_merging_rebase () {
 137         git merge -s ours -m "$(cat "$git_dir"/SHEARS-MERGING-MESSAGE)" "$1"
 138 }
 139
 140 cleanup () {
 141         rm -f "$git_dir"/SHEARS-SCRIPT &&
 142         for rewritten
 143         do
 144                 git update-ref -d refs/rewritten/$rewritten
 145         done &&
 146         for rewritten in $(git for-each-ref refs/rewritten/ |
 147                 sed 's/^[^ ]* commit.refs\/rewritten\///')
 148         do
 149                 test onto = "$rewritten" ||
 150                 merge $rewritten
 151                 git update-ref -d refs/rewritten/$rewritten
 152         done &&
 153         git config --unset alias..r
 154 }
 155
 156 merging=
 157 base_message=
 158 onto=
 159 recreate=
 160 force=
 161 while test $# -gt 0
 162 do
 163         case "$1" in
 164         -m|--merging)
 165                 merging=t
 166                 base_message=
 167                 ;;
 168         --merging=*)
 169                 merging=t
 170                 base_message="${1#--merging=}"
 171                 ;;
 172         --onto)
 173                 shift
 174                 onto="$1"
 175                 ;;
 176         --onto=*)
 177                 onto="${1#--onto=}"
 178                 ;;
 179         --recreate)
 180                 shift
 181                 recreate="$recreate $1"
 182                 ;;
 183         --recreate=*)
 184                 recreate="$recreate ${1#--recreate=}"
 185                 ;;
 186         --force|-f)
 187                 force=t
 188                 ;;
 189         -h|--help)
 190                 help
 191                 ;;
 192         -*)
 193                 echo "Unknown option: $1" >&2
 194                 exit 1
 195                 ;;
 196         *)
 197                 break
 198                 ;;
 199         esac
 200         shift
 201 done
 202
 203 case " $extra_commands " in
 204 *" $1 "*)
 205         command="$1"
 206         shift
 207         "$command" "$@"
 208         exit
 209         ;;
 210 esac
 211
 212 string2regex () {
 213         echo "$*" |
 214         sed 's/[][\\\/*?]/\\&/g'
 215 }
 216
 217 merge2branch_name () {
 218         git show -s --format=%s "$1" |
 219                 sed -n -e "s/^Merge [^']*'\([^']*\).*/\1/p" \
 220                 -e "s/^Merge pull request #[0-9]* from //p" |
 221         tr '    ' '-'
 222 }
 223
 224 commit_name_map=
 225 name_commit () {
 226         name="$(echo "$commit_name_map" |
 227         sed -n "s/^$1 //p")"
 228         echo "${name:-$1}"
 229 }
 230
 231 ensure_labeled () {
 232         for n in "$@"
 233         do
 234                 case " $needslabel " in
 235                 *" $n "*)
 236                         ;;
 237                 *)
 238                         needslabel="$needslabel $n"
 239                         ;;
 240                 esac
 241         done
 242 }
 243
 244 generate_script () {
 245         origtodo="$(git rev-list --no-merges --cherry-pick --pretty=oneline \
 246                 --abbrev-commit --abbrev=7 --reverse --left-right --topo-order \
 247                 $upstream..$head | \
 248                 sed -n "s/^>/pick /p")"
 249         shorthead=$(git rev-parse --short $head)
 250         shortonto=$(git rev-parse --short $onto)
 251
 252         # --topo-order has the bad habit of breaking first-parent chains over
 253         # merges, so we generate the topoligical order ourselves here
 254
 255         list="$(git log --format='%h %p' --topo-order --reverse \
 256                 $upstream..$head)"
 257
 258         todo=
 259         if test -n "$merging"
 260         then
 261                 from=$(git rev-parse --short "$upstream") &&
 262                 to=$(git rev-parse --short "$onto") &&
 263                 cat > "$git_dir"/SHEARS-MERGING-MESSAGE << EOF &&
 264 Start the merging-rebase to $onto
 265
 266 This commit starts the rebase of $from to $to
 267 $base_message
 268 EOF
 269                 todo="start_merging_rebase \"$shorthead\""
 270         fi
 271         todo="$(printf '%s\n%s\n' "$todo" \
 272                 "mark onto")"
 273
 274         toberebased=" $(echo "$list" | cut -f 1 -d ' ' | tr '\n' ' ')"
 275         handled=
 276         needslabel=
 277
 278         # each tip is an end point of a commit->first parent chain
 279         branch_tips="$(echo "$list" |
 280                 cut -f 3- -d ' ' |
 281                 tr ' ' '\n' |
 282                 grep -v '^$')"
 283
 284         ensure_labeled $branch_tips
 285
 286         branch_tips="$(printf '%s\n%s' "$branch_tips" "$shorthead")"
 287
 288         # set up the map tip -> branch name
 289         for tip in $branch_tips
 290         do
 291                 merged_by="$(echo "$list" |
 292                         sed -n "s/^\([^ ]*\) [^ ]* $tip$/\1/p" |
 293                         head -n 1)"
 294                 if test -n "$merged_by"
 295                 then
 296                         branch_name="$(merge2branch_name "$merged_by")"
 297                         test -z "$branch_name" ||
 298                         commit_name_map="$(printf '%s\n%s' \
 299                                 "$tip $branch_name" "$commit_name_map")"
 300                 fi
 301         done
 302         branch_name_dupes="$(echo "$commit_name_map" |
 303                 sed 's/[^ ]* //' |
 304                 sort |
 305                 uniq -d)"
 306         if test -n "$branch_name_dupes"
 307         then
 308                 exprs="$(echo "$branch_name_dupes" |
 309                         while read branch_name
 310                         do
 311                                 printf " -e '%s'" \
 312                                         "$(string2regex "$branch_name")"
 313                         done)"
 314                 commit_name_map="$(echo "$commit_name_map" |
 315                         eval grep -v $exprs)"
 316         fi
 317
 318         for tip in $branch_tips
 319         do
 320                 # if this is not a commit to be rebased, skip
 321                 case "$toberebased" in *" $tip "*) ;; *) continue;; esac
 322
 323                 # if it is handled already, skip
 324                 case "$handled " in *" $tip "*) continue;; esac
 325
 326                 # start sub-todo for this tip
 327                 subtodo=
 328                 commit=$tip
 329                 while true
 330                 do
 331                         # if already handled, this is our branch point
 332                         case "$handled " in
 333                         *" $commit "*)
 334                                 ensure_labeled $commit
 335                                 subtodo="$(printf '\nrewind %s # %s\n%s' \
 336                                         "$(name_commit $commit)" \
 337                                         "$(git show -s --format=%s $commit)" \
 338                                         "$subtodo")"
 339                                 break
 340                                 ;;
 341                         esac
 342
 343                         line="$(echo "$list" | grep "^$commit ")"
 344                         # if there is no line, branch from the 'onto' commit
 345                         if test -z "$line"
 346                         then
 347                                 subtodo="$(printf '\nbud\n%s' \
 348                                         "$subtodo")"
 349                                 break
 350                         fi
 351                         parents=${line#* }
 352                         case "$parents" in
 353                         *' '*)
 354                                 # merge
 355                                 parents2="`for parent in ${parents#* }
 356                                         do
 357                                                 case "$toberebased" in
 358                                                 *" $parent "*)
 359                                                         printf refs/rewritten/
 360                                                         ;;
 361                                                 esac
 362                                                 echo "$(name_commit $parent) "
 363                                         done`"
 364                                 subtodo="$(printf '%s # %s\n%s' \
 365                                         "merge $parents2-C $commit" \
 366                                         "$(git show -s --format=%s $commit)" \
 367                                         "$subtodo")"
 368                                 ;;
 369                         *)
 370                                 # non-merge commit
 371                                 line="$(echo "$origtodo" |
 372                                         grep "^pick $commit")"
 373                                 if test -z "$line"
 374                                 then
 375                                         line="# skip $commit"
 376                                 fi
 377                                 subtodo="$(printf '%s\n%s' "$line" "$subtodo")"
 378                                 ;;
 379                         esac
 380                         handled="$handled $commit"
 381                         commit=${parents%% *}
 382                 done
 383
 384                 branch_name="$(name_commit "$tip")"
 385                 test -n "$branch_name" &&
 386                 test "$branch_name" = "$tip" ||
 387                 subtodo="$(echo "$subtodo" |
 388                         sed -e "1a\\
 389 # Branch: $branch_name")"
 390
 391                 todo="$(printf '%s\n\n%s' "$todo" "$subtodo")"
 392         done
 393
 394         for commit in $needslabel
 395         do
 396                 linenumber="$(echo "$todo" |
 397                         grep -n -e "^\(pick\|# skip\) $commit" \
 398                                 -e "^merge [0-9a-f/ ]* -C $commit")"
 399                 linenumber=${linenumber%%:*}
 400                 test -n "$linenumber" ||
 401                 die "Internal error: could not find $commit in $todo"
 402                 todo="$(echo "$todo" |
 403                         sed "${linenumber}a\\
 404 mark $(name_commit $commit)\\
 405 ")"
 406         done
 407
 408         lastline=9999
 409         while true
 410         do
 411                 fixup="$(echo "$todo" |
 412                         sed "$lastline,\$d" |
 413                         grep -n -e '^pick [^ ]* \(fixup\|squash\)!' |
 414                         tail -n 1)"
 415                 test -n "$fixup" || break
 416
 417                 linenumber=${fixup%%:*}
 418                 oneline="${fixup#* }"
 419                 shortsha1="${oneline%% *}"
 420                 oneline="${oneline#* }"
 421                 command=${oneline%%!*}
 422                 oneline="${oneline#*! }"
 423                 oneline_regex="^pick [^ ]* $(string2regex "$oneline")\$"
 424                 targetline="$(echo "$todo" |
 425                         sed "$linenumber,\$d" |
 426                         grep -n "$oneline_regex" |
 427                         tail -n 1)"
 428                 targetline=${targetline%%:*}
 429                 if test -n "$targetline"
 430                 then
 431                         todo="$(echo "$todo" |
 432                                 sed -e "${linenumber}d" \
 433                                         -e "${targetline}a\\
 434 $command $shortsha1 $oneline")"
 435                         lastline=$(($linenumber+1))
 436                 else
 437                         echo "UNHANDLED: $oneline" >&2
 438                         lastline=$(($linenumber))
 439                 fi
 440         done
 441
 442         while test -n "$recreate"
 443         do
 444                 recreate="${recreate# }"
 445                 merge="${recreate%% *}"
 446                 recreate="${recreate#$merge}"
 447
 448                 mark="$(git rev-parse --short --verify "$merge^2")" ||
 449                 die "Could not find merge commit: $merge^2"
 450
 451                 branch_name="$(merge2branch_name "$merge")"
 452                 partfile="$git_dir/SHEARS-PART"
 453                 printf '%s' "$(test -z "$branch_name" ||
 454                            echo "# Branch to recreate: $branch_name")" \
 455                         > "$partfile"
 456                 for sha1 in $(git rev-list --reverse $merge^..$merge^2)
 457                 do
 458                         msg="$(git show -s --format=%s $sha1)"
 459                         msg_regex="^pick [^ ]* $(string2regex "$msg")\$"
 460                         linenumber="$(echo "$todo" |
 461                                 grep -n "$msg_regex" |
 462                                 sed 's/:.*//')"
 463                         test -n "$linenumber" ||
 464                         die "Not a commit to rebase: $msg"
 465                         test 1 = $(echo "$linenumber" | wc -l) ||
 466                         die "More than one match for: $msg"
 467                         echo "$todo" |
 468                         sed -n "${linenumber}p" >> "$partfile"
 469                         todo="$(echo "$todo" |
 470                                 sed "${linenumber}d")"
 471                 done
 472
 473                 linenumber="$(echo "$todo" |
 474                         grep -n "^bud\$" |
 475                         tail -n 1 |
 476                         sed 's/:.*//')"
 477
 478                 printf 'mark %s\n\nbud\n' \
 479                         "$(name_commit $mark)" >> "$partfile"
 480                 todo="$(echo "$todo" |
 481                         sed -e "${linenumber}r$partfile" \
 482                                 -e "\$a\\
 483 merge refs/rewritten/$mark -C $(name_commit $merge)")"
 484         done
 485
 486         needslabel="$(for commit in $needslabel
 487                 do
 488                         printf ' %s' $(name_commit $commit)
 489                 done)"
 490         todo="$(printf '%s\n\n%s' "$todo" "cleanup $needslabel")"
 491         echo "$todo" | uniq
 492 }
 493
 494 this="$(cd "$(dirname "$0")" && pwd)/$(basename "$0")"
 495 setup () {
 496         existing=$(git for-each-ref --format='%(refname)' refs/rewritten/)
 497         test -z "$existing" ||
 498         if test -n "$force"
 499         then
 500                 for ref in $existing
 501                 do
 502                         git update-ref -d $ref
 503                 done
 504         else
 505                 die "$(printf '%s %s:\n%s\n' \
 506                         'There are still rewritten revisions' \
 507                         '(use --force to delete)' \
 508                         "$existing")"
 509         fi
 510
 511         alias="$(git config --get alias..r)"
 512         test -z "$alias" ||
 513         test "a$alias" = "a!sh \"$this\"" ||
 514         test -n "$force" ||
 515         die "There is already an '.r' alias!"
 516
 517         git config alias..r "!sh \"$this\"" &&
 518         generate_script > "$git_dir"/SHEARS-SCRIPT &&
 519         GIT_EDITOR="$(cd "$git_dir" && pwd)/SHEARS-EDITOR" &&
 520         cat > "$GIT_EDITOR" << EOF &&
 521 #!/bin/sh
 522
 523 exec "$this" edit "$(git var GIT_EDITOR)" "\$@"
 524 EOF
 525         chmod +x "$GIT_EDITOR" &&
 526         GIT_EDITOR="\"$GIT_EDITOR\"" &&
 527         GIT_SEQUENCE_EDITOR="$GIT_EDITOR" &&
 528         export GIT_EDITOR GIT_SEQUENCE_EDITOR
 529 }
 530
 531 test ! -d "$git_dir"/rebase-merge &&
 532 test ! -d "$git_dir"/rebase-apply ||
 533 die "Rebase already in progress"
 534
 535 test $# = 1 ||
 536 help
 537
 538 head="$(git rev-parse HEAD)" &&
 539 upstream="$1" &&
 540 onto=${onto:-$upstream}||
 541 die "Could not determine rebase parameters"
 542
 543 git update-index -q --ignore-submodules --refresh &&
 544 git diff-files --quiet --ignore-submodules &&
 545 git diff-index --cached --quiet --ignore-submodules HEAD -- ||
 546 die 'There are uncommitted changes!'
 547
 548 setup
 549
 550 # Rebase!
 551 git rebase -i --onto "$onto" HEAD
 552