git.oblomov.eu Git - git/blob - contrib/subtree/git-subtree.sh

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