bin/git-subtree

   1 #!/bin/bash
   2 #
   3 # git-subtree.sh: split/join git repositories in subdirectories of this one
   4 #
   5 # Copyright (C) 2009 Avery Pennarun <apenwarr@gmail.com>
   6 #
   7 if [ $# -eq 0 ]; then
   8     set -- -h
   9 fi
  10 OPTS_SPEC="\
  11 git subtree add   --prefix=<prefix> <commit>
  12 git subtree merge --prefix=<prefix> <commit>
  13 git subtree pull  --prefix=<prefix> <repository> <refspec...>
  14 git subtree push  --prefix=<prefix> <repository> <refspec...>
  15 git subtree split --prefix=<prefix> <commit...>
  16 --
  17 h,help        show the help
  18 q             quiet
  19 d             show debug messages
  20 P,prefix=     the name of the subdir to split out
  21 m,message=    use the given message as the commit message for the merge commit
  22  options for 'split'
  23 annotate=     add a prefix to commit message of new commits
  24 b,branch=     create a new branch from the split subtree
  25 ignore-joins  ignore prior --rejoin commits
  26 onto=         try connecting new tree to an existing one
  27 rejoin        merge the new branch back into HEAD
  28  options for 'add', 'merge', 'pull' and 'push'
  29 squash        merge subtree changes as a single commit
  30 "
  31 eval $(echo "$OPTS_SPEC" | git rev-parse --parseopt -- "$@" || echo exit $?)
  32
  33 PATH=$PATH:$(git --exec-path)
  34 . git-sh-setup
  35
  36 require_work_tree
  37
  38 quiet=
  39 branch=
  40 debug=
  41 command=
  42 onto=
  43 rejoin=
  44 ignore_joins=
  45 annotate=
  46 squash=
  47 message=
  48
  49 debug()
  50 {
  51         if [ -n "$debug" ]; then
  52                 echo "$@" >&2
  53         fi
  54 }
  55
  56 say()
  57 {
  58         if [ -z "$quiet" ]; then
  59                 echo "$@" >&2
  60         fi
  61 }
  62
  63 assert()
  64 {
  65         if "$@"; then
  66                 :
  67         else
  68                 die "assertion failed: " "$@"
  69         fi
  70 }
  71
  72
  73 #echo "Options: $*"
  74
  75 while [ $# -gt 0 ]; do
  76         opt="$1"
  77         shift
  78         case "$opt" in
  79                 -q) quiet=1 ;;
  80                 -d) debug=1 ;;
  81                 --annotate) annotate="$1"; shift ;;
  82                 --no-annotate) annotate= ;;
  83                 -b) branch="$1"; shift ;;
  84                 -P) prefix="$1"; shift ;;
  85                 -m) message="$1"; shift ;;
  86                 --no-prefix) prefix= ;;
  87                 --onto) onto="$1"; shift ;;
  88                 --no-onto) onto= ;;
  89                 --rejoin) rejoin=1 ;;
  90                 --no-rejoin) rejoin= ;;
  91                 --ignore-joins) ignore_joins=1 ;;
  92                 --no-ignore-joins) ignore_joins= ;;
  93                 --squash) squash=1 ;;
  94                 --no-squash) squash= ;;
  95                 --) break ;;
  96                 *) die "Unexpected option: $opt" ;;
  97         esac
  98 done
  99
 100 command="$1"
 101 shift
 102 case "$command" in
 103         add|merge|pull) default= ;;
 104         split|push) default="--default HEAD" ;;
 105         *) die "Unknown command '$command'" ;;
 106 esac
 107
 108 if [ -z "$prefix" ]; then
 109         die "You must provide the --prefix option."
 110 fi
 111
 112 case "$command" in
 113         add) [ -e "$prefix" ] &&
 114                 die "prefix '$prefix' already exists." ;;
 115         *)   [ -e "$prefix" ] ||
 116                 die "'$prefix' does not exist; use 'git subtree add'" ;;
 117 esac
 118
 119 dir="$(dirname "$prefix/.")"
 120
 121 if [ "$command" != "pull" -a "$command" != "add" -a "$command" != "push" ]; then
 122         revs=$(git rev-parse $default --revs-only "$@") || exit $?
 123         dirs="$(git rev-parse --no-revs --no-flags "$@")" || exit $?
 124         if [ -n "$dirs" ]; then
 125                 die "Error: Use --prefix instead of bare filenames."
 126         fi
 127 fi
 128
 129 debug "command: {$command}"
 130 debug "quiet: {$quiet}"
 131 debug "revs: {$revs}"
 132 debug "dir: {$dir}"
 133 debug "opts: {$*}"
 134 debug
 135
 136 cache_setup()
 137 {
 138         cachedir="$GIT_DIR/subtree-cache/$$"
 139         rm -rf "$cachedir" || die "Can't delete old cachedir: $cachedir"
 140         mkdir -p "$cachedir" || die "Can't create new cachedir: $cachedir"
 141         debug "Using cachedir: $cachedir" >&2
 142 }
 143
 144 cache_get()
 145 {
 146         for oldrev in $*; do
 147                 if [ -r "$cachedir/$oldrev" ]; then
 148                         read newrev <"$cachedir/$oldrev"
 149                         echo $newrev
 150                 fi
 151         done
 152 }
 153
 154 cache_set()
 155 {
 156         oldrev="$1"
 157         newrev="$2"
 158         if [ "$oldrev" != "latest_old" \
 159              -a "$oldrev" != "latest_new" \
 160              -a -e "$cachedir/$oldrev" ]; then
 161                 die "cache for $oldrev already exists!"
 162         fi
 163         echo "$newrev" >"$cachedir/$oldrev"
 164 }
 165
 166 rev_exists()
 167 {
 168         if git rev-parse "$1" >/dev/null 2>&1; then
 169                 return 0
 170         else
 171                 return 1
 172         fi
 173 }
 174
 175 rev_is_descendant_of_branch()
 176 {
 177         newrev="$1"
 178         branch="$2"
 179         branch_hash=$(git rev-parse $branch)
 180         match=$(git rev-list -1 $branch_hash ^$newrev)
 181
 182         if [ -z "$match" ]; then
 183                 return 0
 184         else
 185                 return 1
 186         fi
 187 }
 188
 189 # if a commit doesn't have a parent, this might not work.  But we only want
 190 # to remove the parent from the rev-list, and since it doesn't exist, it won't
 191 # be there anyway, so do nothing in that case.
 192 try_remove_previous()
 193 {
 194         if rev_exists "$1^"; then
 195                 echo "^$1^"
 196         fi
 197 }
 198
 199 find_latest_squash()
 200 {
 201         debug "Looking for latest squash ($dir)..."
 202         dir="$1"
 203         sq=
 204         main=
 205         sub=
 206         git log --grep="^git-subtree-dir: $dir/*\$" \
 207                 --pretty=format:'START %H%n%s%n%n%b%nEND%n' HEAD |
 208         while read a b junk; do
 209                 debug "$a $b $junk"
 210                 debug "{{$sq/$main/$sub}}"
 211                 case "$a" in
 212                         START) sq="$b" ;;
 213                         git-subtree-mainline:) main="$b" ;;
 214                         git-subtree-split:) sub="$b" ;;
 215                         END)
 216                                 if [ -n "$sub" ]; then
 217                                         if [ -n "$main" ]; then
 218                                                 # a rejoin commit?
 219                                                 # Pretend its sub was a squash.
 220                                                 sq="$sub"
 221                                         fi
 222                                         debug "Squash found: $sq $sub"
 223                                         echo "$sq" "$sub"
 224                                         break
 225                                 fi
 226                                 sq=
 227                                 main=
 228                                 sub=
 229                                 ;;
 230                 esac
 231         done
 232 }
 233
 234 find_existing_splits()
 235 {
 236         debug "Looking for prior splits..."
 237         dir="$1"
 238         revs="$2"
 239         main=
 240         sub=
 241         git log --grep="^git-subtree-dir: $dir/*\$" \
 242                 --pretty=format:'START %H%n%s%n%n%b%nEND%n' $revs |
 243         while read a b junk; do
 244                 case "$a" in
 245                         START) sq="$b" ;;
 246                         git-subtree-mainline:) main="$b" ;;
 247                         git-subtree-split:) sub="$b" ;;
 248                         END)
 249                                 debug "  Main is: '$main'"
 250                                 if [ -z "$main" -a -n "$sub" ]; then
 251                                         # squash commits refer to a subtree
 252                                         debug "  Squash: $sq from $sub"
 253                                         cache_set "$sq" "$sub"
 254                                 fi
 255                                 if [ -n "$main" -a -n "$sub" ]; then
 256                                         debug "  Prior: $main -> $sub"
 257                                         cache_set $main $sub
 258                                         cache_set $sub $sub
 259                                         try_remove_previous "$main"
 260                                         try_remove_previous "$sub"
 261                                 fi
 262                                 main=
 263                                 sub=
 264                                 ;;
 265                 esac
 266         done
 267 }
 268
 269 copy_commit()
 270 {
 271         # We're going to set some environment vars here, so
 272         # do it in a subshell to get rid of them safely later
 273         debug copy_commit "{$1}" "{$2}" "{$3}"
 274         git log -1 --pretty=format:'%an%n%ae%n%ad%n%cn%n%ce%n%cd%n%s%n%n%b' "$1" |
 275         (
 276                 read GIT_AUTHOR_NAME
 277                 read GIT_AUTHOR_EMAIL
 278                 read GIT_AUTHOR_DATE
 279                 read GIT_COMMITTER_NAME
 280                 read GIT_COMMITTER_EMAIL
 281                 read GIT_COMMITTER_DATE
 282                 export  GIT_AUTHOR_NAME \
 283                         GIT_AUTHOR_EMAIL \
 284                         GIT_AUTHOR_DATE \
 285                         GIT_COMMITTER_NAME \
 286                         GIT_COMMITTER_EMAIL \
 287                         GIT_COMMITTER_DATE
 288                 (echo -n "$annotate"; cat ) |
 289                 git commit-tree "$2" $3  # reads the rest of stdin
 290         ) || die "Can't copy commit $1"
 291 }
 292
 293 add_msg()
 294 {
 295         dir="$1"
 296         latest_old="$2"
 297         latest_new="$3"
 298         if [ -n "$message" ]; then
 299                 commit_message="$message"
 300         else
 301                 commit_message="Add '$dir/' from commit '$latest_new'"
 302         fi
 303         cat <<-EOF
 304                 $commit_message
 305
 306                 git-subtree-dir: $dir
 307                 git-subtree-mainline: $latest_old
 308                 git-subtree-split: $latest_new
 309         EOF
 310 }
 311
 312 add_squashed_msg()
 313 {
 314         if [ -n "$message" ]; then
 315                 echo "$message"
 316         else
 317                 echo "Merge commit '$1' as '$2'"
 318         fi
 319 }
 320
 321 rejoin_msg()
 322 {
 323         dir="$1"
 324         latest_old="$2"
 325         latest_new="$3"
 326         if [ -n "$message" ]; then
 327                 commit_message="$message"
 328         else
 329                 commit_message="Split '$dir/' into commit '$latest_new'"
 330         fi
 331         cat <<-EOF
 332                 $commit_message
 333
 334                 git-subtree-dir: $dir
 335                 git-subtree-mainline: $latest_old
 336                 git-subtree-split: $latest_new
 337         EOF
 338 }
 339
 340 squash_msg()
 341 {
 342         dir="$1"
 343         oldsub="$2"
 344         newsub="$3"
 345         newsub_short=$(git rev-parse --short "$newsub")
 346
 347         if [ -n "$oldsub" ]; then
 348                 oldsub_short=$(git rev-parse --short "$oldsub")
 349                 echo "Squashed '$dir/' changes from $oldsub_short..$newsub_short"
 350                 echo
 351                 git log --pretty=tformat:'%h %s' "$oldsub..$newsub"
 352                 git log --pretty=tformat:'REVERT: %h %s' "$newsub..$oldsub"
 353         else
 354                 echo "Squashed '$dir/' content from commit $newsub_short"
 355         fi
 356
 357         echo
 358         echo "git-subtree-dir: $dir"
 359         echo "git-subtree-split: $newsub"
 360 }
 361
 362 toptree_for_commit()
 363 {
 364         commit="$1"
 365         git log -1 --pretty=format:'%T' "$commit" -- || exit $?
 366 }
 367
 368 subtree_for_commit()
 369 {
 370         commit="$1"
 371         dir="$2"
 372         git ls-tree "$commit" -- "$dir" |
 373         while read mode type tree name; do
 374                 assert [ "$name" = "$dir" ]
 375                 assert [ "$type" = "tree" ]
 376                 echo $tree
 377                 break
 378         done
 379 }
 380
 381 tree_changed()
 382 {
 383         tree=$1
 384         shift
 385         if [ $# -ne 1 ]; then
 386                 return 0   # weird parents, consider it changed
 387         else
 388                 ptree=$(toptree_for_commit $1)
 389                 if [ "$ptree" != "$tree" ]; then
 390                         return 0   # changed
 391                 else
 392                         return 1   # not changed
 393                 fi
 394         fi
 395 }
 396
 397 new_squash_commit()
 398 {
 399         old="$1"
 400         oldsub="$2"
 401         newsub="$3"
 402         tree=$(toptree_for_commit $newsub) || exit $?
 403         if [ -n "$old" ]; then
 404                 squash_msg "$dir" "$oldsub" "$newsub" |
 405                         git commit-tree "$tree" -p "$old" || exit $?
 406         else
 407                 squash_msg "$dir" "" "$newsub" |
 408                         git commit-tree "$tree" || exit $?
 409         fi
 410 }
 411
 412 copy_or_skip()
 413 {
 414         rev="$1"
 415         tree="$2"
 416         newparents="$3"
 417         assert [ -n "$tree" ]
 418
 419         identical=
 420         nonidentical=
 421         p=
 422         gotparents=
 423         for parent in $newparents; do
 424                 ptree=$(toptree_for_commit $parent) || exit $?
 425                 [ -z "$ptree" ] && continue
 426                 if [ "$ptree" = "$tree" ]; then
 427                         # an identical parent could be used in place of this rev.
 428                         identical="$parent"
 429                 else
 430                         nonidentical="$parent"
 431                 fi
 432
 433                 # sometimes both old parents map to the same newparent;
 434                 # eliminate duplicates
 435                 is_new=1
 436                 for gp in $gotparents; do
 437                         if [ "$gp" = "$parent" ]; then
 438                                 is_new=
 439                                 break
 440                         fi
 441                 done
 442                 if [ -n "$is_new" ]; then
 443                         gotparents="$gotparents $parent"
 444                         p="$p -p $parent"
 445                 fi
 446         done
 447
 448         if [ -n "$identical" ]; then
 449                 echo $identical
 450         else
 451                 copy_commit $rev $tree "$p" || exit $?
 452         fi
 453 }
 454
 455 ensure_clean()
 456 {
 457         if ! git diff-index HEAD --exit-code --quiet 2>&1; then
 458                 die "Working tree has modifications.  Cannot add."
 459         fi
 460         if ! git diff-index --cached HEAD --exit-code --quiet 2>&1; then
 461                 die "Index has modifications.  Cannot add."
 462         fi
 463 }
 464
 465 cmd_add()
 466 {
 467         if [ -e "$dir" ]; then
 468                 die "'$dir' already exists.  Cannot add."
 469         fi
 470
 471         ensure_clean
 472
 473         if [ $# -eq 1 ]; then
 474                 "cmd_add_commit" "$@"
 475         elif [ $# -eq 2 ]; then
 476                 "cmd_add_repository" "$@"
 477         else
 478             say "error: parameters were '$@'"
 479             die "Provide either a refspec or a repository and refspec."
 480         fi
 481 }
 482
 483 cmd_add_repository()
 484 {
 485         echo "git fetch" "$@"
 486         repository=$1
 487         refspec=$2
 488         git fetch "$@" || exit $?
 489         revs=FETCH_HEAD
 490         set -- $revs
 491         cmd_add_commit "$@"
 492 }
 493
 494 cmd_add_commit()
 495 {
 496         revs=$(git rev-parse $default --revs-only "$@") || exit $?
 497         set -- $revs
 498         rev="$1"
 499
 500         debug "Adding $dir as '$rev'..."
 501         git read-tree --prefix="$dir" $rev || exit $?
 502         git checkout -- "$dir" || exit $?
 503         tree=$(git write-tree) || exit $?
 504
 505         headrev=$(git rev-parse HEAD) || exit $?
 506         if [ -n "$headrev" -a "$headrev" != "$rev" ]; then
 507                 headp="-p $headrev"
 508         else
 509                 headp=
 510         fi
 511
 512         if [ -n "$squash" ]; then
 513                 rev=$(new_squash_commit "" "" "$rev") || exit $?
 514                 commit=$(add_squashed_msg "$rev" "$dir" |
 515                          git commit-tree $tree $headp -p "$rev") || exit $?
 516         else
 517                 commit=$(add_msg "$dir" "$headrev" "$rev" |
 518                          git commit-tree $tree $headp -p "$rev") || exit $?
 519         fi
 520         git reset "$commit" || exit $?
 521
 522         say "Added dir '$dir'"
 523 }
 524
 525 cmd_split()
 526 {
 527         debug "Splitting $dir..."
 528         cache_setup || exit $?
 529
 530         if [ -n "$onto" ]; then
 531                 debug "Reading history for --onto=$onto..."
 532                 git rev-list $onto |
 533                 while read rev; do
 534                         # the 'onto' history is already just the subdir, so
 535                         # any parent we find there can be used verbatim
 536                         debug "  cache: $rev"
 537                         cache_set $rev $rev
 538                 done
 539         fi
 540
 541         if [ -n "$ignore_joins" ]; then
 542                 unrevs=
 543         else
 544                 unrevs="$(find_existing_splits "$dir" "$revs")"
 545         fi
 546
 547         # We can't restrict rev-list to only $dir here, because some of our
 548         # parents have the $dir contents the root, and those won't match.
 549         # (and rev-list --follow doesn't seem to solve this)
 550         grl='git rev-list --reverse --parents $revs $unrevs'
 551         revmax=$(eval "$grl" | wc -l)
 552         revcount=0
 553         createcount=0
 554         eval "$grl" |
 555         while read rev parents; do
 556                 revcount=$(($revcount + 1))
 557                 say -n "$revcount/$revmax ($createcount)
"
 558                 debug "Processing commit: $rev"
 559                 exists=$(cache_get $rev)
 560                 if [ -n "$exists" ]; then
 561                         debug "  prior: $exists"
 562                         continue
 563                 fi
 564                 createcount=$(($createcount + 1))
 565                 debug "  parents: $parents"
 566                 newparents=$(cache_get $parents)
 567                 debug "  newparents: $newparents"
 568
 569                 tree=$(subtree_for_commit $rev "$dir")
 570                 debug "  tree is: $tree"
 571
 572                 # ugly.  is there no better way to tell if this is a subtree
 573                 # vs. a mainline commit?  Does it matter?
 574                 if [ -z $tree ]; then
 575                         if [ -n "$newparents" ]; then
 576                                 cache_set $rev $rev
 577                         fi
 578                         continue
 579                 fi
 580
 581                 newrev=$(copy_or_skip "$rev" "$tree" "$newparents") || exit $?
 582                 debug "  newrev is: $newrev"
 583                 cache_set $rev $newrev
 584                 cache_set latest_new $newrev
 585                 cache_set latest_old $rev
 586         done || exit $?
 587         latest_new=$(cache_get latest_new)
 588         if [ -z "$latest_new" ]; then
 589                 die "No new revisions were found"
 590         fi
 591
 592         if [ -n "$rejoin" ]; then
 593                 debug "Merging split branch into HEAD..."
 594                 latest_old=$(cache_get latest_old)
 595                 git merge -s ours \
 596                         -m "$(rejoin_msg $dir $latest_old $latest_new)" \
 597                         $latest_new >&2 || exit $?
 598         fi
 599         if [ -n "$branch" ]; then
 600                 if rev_exists "refs/heads/$branch"; then
 601                         if ! rev_is_descendant_of_branch $latest_new $branch; then
 602                                 die "Branch '$branch' is not an ancestor of commit '$latest_new'."
 603                         fi
 604                         action='Updated'
 605                 else
 606                         action='Created'
 607                 fi
 608                 git update-ref -m 'subtree split' "refs/heads/$branch" $latest_new || exit $?
 609                 say "$action branch '$branch'"
 610         fi
 611         echo $latest_new
 612         exit 0
 613 }
 614
 615 cmd_merge()
 616 {
 617         revs=$(git rev-parse $default --revs-only "$@") || exit $?
 618         ensure_clean
 619
 620         set -- $revs
 621         if [ $# -ne 1 ]; then
 622                 die "You must provide exactly one revision.  Got: '$revs'"
 623         fi
 624         rev="$1"
 625
 626         if [ -n "$squash" ]; then
 627                 first_split="$(find_latest_squash "$dir")"
 628                 if [ -z "$first_split" ]; then
 629                         die "Can't squash-merge: '$dir' was never added."
 630                 fi
 631                 set $first_split
 632                 old=$1
 633                 sub=$2
 634                 if [ "$sub" = "$rev" ]; then
 635                         say "Subtree is already at commit $rev."
 636                         exit 0
 637                 fi
 638                 new=$(new_squash_commit "$old" "$sub" "$rev") || exit $?
 639                 debug "New squash commit: $new"
 640                 rev="$new"
 641         fi
 642
 643         version=$(git version)
 644         if [ "$version" \< "git version 1.7" ]; then
 645                 if [ -n "$message" ]; then
 646                         git merge -s subtree --message="$message" $rev
 647                 else
 648                         git merge -s subtree $rev
 649                 fi
 650         else
 651                 if [ -n "$message" ]; then
 652                         git merge -Xsubtree="$prefix" --message="$message" $rev
 653                 else
 654                         git merge -Xsubtree="$prefix" $rev
 655                 fi
 656         fi
 657 }
 658
 659 cmd_pull()
 660 {
 661         ensure_clean
 662         git fetch "$@" || exit $?
 663         revs=FETCH_HEAD
 664         set -- $revs
 665         cmd_merge "$@"
 666 }
 667
 668 cmd_push()
 669 {
 670         if [ $# -ne 2 ]; then
 671             die "You must provide <repository> <refspec>"
 672         fi
 673         if [ -e "$dir" ]; then
 674             repository=$1
 675             refspec=$2
 676             echo "git push using: " $repository $refspec
 677             git push $repository $(git subtree split --prefix=$prefix):refs/heads/$refspec
 678         else
 679             die "'$dir' must already exist. Try 'git subtree add'."
 680         fi
 681 }
 682
 683 "cmd_$command" "$@"