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