git-submodule.sh

   1 #!/bin/sh
   2 #
   3 # git-submodules.sh: add, init, update or list git submodules
   4 #
   5 # Copyright (c) 2007 Lars Hjemli
   6
   7 USAGE="[--quiet] [--cached] \
   8 [add [-b branch] <repo> <path>]|[status|init|update [-i|--init] [-N|--no-fetch]|summary [-n|--summary-limit <n>] [<commit>]] \
   9 [--] [<path>...]|[foreach <command>]|[sync [--] [<path>...]]"
  10 OPTIONS_SPEC=
  11 . git-sh-setup
  12 . git-parse-remote
  13 require_work_tree
  14
  15 command=
  16 branch=
  17 quiet=
  18 reference=
  19 cached=
  20 nofetch=
  21
  22 #
  23 # print stuff on stdout unless -q was specified
  24 #
  25 say()
  26 {
  27         if test -z "$quiet"
  28         then
  29                 echo "$@"
  30         fi
  31 }
  32
  33 # Resolve relative url by appending to parent's url
  34 resolve_relative_url ()
  35 {
  36         remote=$(get_default_remote)
  37         remoteurl=$(git config "remote.$remote.url") ||
  38                 die "remote ($remote) does not have a url defined in .git/config"
  39         url="$1"
  40         remoteurl=${remoteurl%/}
  41         while test -n "$url"
  42         do
  43                 case "$url" in
  44                 ../*)
  45                         url="${url#../}"
  46                         remoteurl="${remoteurl%/*}"
  47                         ;;
  48                 ./*)
  49                         url="${url#./}"
  50                         ;;
  51                 *)
  52                         break;;
  53                 esac
  54         done
  55         echo "$remoteurl/${url%/}"
  56 }
  57
  58 #
  59 # Get submodule info for registered submodules
  60 # $@ = path to limit submodule list
  61 #
  62 module_list()
  63 {
  64         git ls-files --error-unmatch --stage -- "$@" | grep '^160000 '
  65 }
  66
  67 #
  68 # Map submodule path to submodule name
  69 #
  70 # $1 = path
  71 #
  72 module_name()
  73 {
  74         # Do we have "submodule.<something>.path = $1" defined in .gitmodules file?
  75         re=$(printf '%s\n' "$1" | sed -e 's/[].[^$\\*]/\\&/g')
  76         name=$( git config -f .gitmodules --get-regexp '^submodule\..*\.path$' |
  77                 sed -n -e 's|^submodule\.\(.*\)\.path '"$re"'$|\1|p' )
  78        test -z "$name" &&
  79        die "No submodule mapping found in .gitmodules for path '$path'"
  80        echo "$name"
  81 }
  82
  83 #
  84 # Clone a submodule
  85 #
  86 # Prior to calling, cmd_update checks that a possibly existing
  87 # path is not a git repository.
  88 # Likewise, cmd_add checks that path does not exist at all,
  89 # since it is the location of a new submodule.
  90 #
  91 module_clone()
  92 {
  93         path=$1
  94         url=$2
  95         reference="$3"
  96
  97         # If there already is a directory at the submodule path,
  98         # expect it to be empty (since that is the default checkout
  99         # action) and try to remove it.
 100         # Note: if $path is a symlink to a directory the test will
 101         # succeed but the rmdir will fail. We might want to fix this.
 102         if test -d "$path"
 103         then
 104                 rmdir "$path" 2>/dev/null ||
 105                 die "Directory '$path' exist, but is neither empty nor a git repository"
 106         fi
 107
 108         test -e "$path" &&
 109         die "A file already exist at path '$path'"
 110
 111         if test -n "$reference"
 112         then
 113                 git-clone "$reference" -n "$url" "$path"
 114         else
 115                 git-clone -n "$url" "$path"
 116         fi ||
 117         die "Clone of '$url' into submodule path '$path' failed"
 118 }
 119
 120 #
 121 # Add a new submodule to the working tree, .gitmodules and the index
 122 #
 123 # $@ = repo path
 124 #
 125 # optional branch is stored in global branch variable
 126 #
 127 cmd_add()
 128 {
 129         # parse $args after "submodule ... add".
 130         while test $# -ne 0
 131         do
 132                 case "$1" in
 133                 -b | --branch)
 134                         case "$2" in '') usage ;; esac
 135                         branch=$2
 136                         shift
 137                         ;;
 138                 -q|--quiet)
 139                         quiet=1
 140                         ;;
 141                 --reference)
 142                         case "$2" in '') usage ;; esac
 143                         reference="--reference=$2"
 144                         shift
 145                         ;;
 146                 --reference=*)
 147                         reference="$1"
 148                         shift
 149                         ;;
 150                 --)
 151                         shift
 152                         break
 153                         ;;
 154                 -*)
 155                         usage
 156                         ;;
 157                 *)
 158                         break
 159                         ;;
 160                 esac
 161                 shift
 162         done
 163
 164         repo=$1
 165         path=$2
 166
 167         if test -z "$repo" -o -z "$path"; then
 168                 usage
 169         fi
 170
 171         # assure repo is absolute or relative to parent
 172         case "$repo" in
 173         ./*|../*)
 174                 # dereference source url relative to parent's url
 175                 realrepo=$(resolve_relative_url "$repo") || exit
 176                 ;;
 177         *:*|/*)
 178                 # absolute url
 179                 realrepo=$repo
 180                 ;;
 181         *)
 182                 die "repo URL: '$repo' must be absolute or begin with ./|../"
 183         ;;
 184         esac
 185
 186         # normalize path:
 187         # multiple //; leading ./; /./; /../; trailing /
 188         path=$(printf '%s/\n' "$path" |
 189                 sed -e '
 190                         s|//*|/|g
 191                         s|^\(\./\)*||
 192                         s|/\./|/|g
 193                         :start
 194                         s|\([^/]*\)/\.\./||
 195                         tstart
 196                         s|/*$||
 197                 ')
 198         git ls-files --error-unmatch "$path" > /dev/null 2>&1 &&
 199         die "'$path' already exists in the index"
 200
 201         # perhaps the path exists and is already a git repo, else clone it
 202         if test -e "$path"
 203         then
 204                 if test -d "$path"/.git -o -f "$path"/.git
 205                 then
 206                         echo "Adding existing repo at '$path' to the index"
 207                 else
 208                         die "'$path' already exists and is not a valid git repo"
 209                 fi
 210
 211                 case "$repo" in
 212                 ./*|../*)
 213                         url=$(resolve_relative_url "$repo") || exit
 214                     ;;
 215                 *)
 216                         url="$repo"
 217                         ;;
 218                 esac
 219                 git config submodule."$path".url "$url"
 220         else
 221
 222                 module_clone "$path" "$realrepo" "$reference" || exit
 223                 (
 224                         unset GIT_DIR
 225                         cd "$path" &&
 226                         # ash fails to wordsplit ${branch:+-b "$branch"...}
 227                         case "$branch" in
 228                         '') git checkout -f -q ;;
 229                         ?*) git checkout -f -q -b "$branch" "origin/$branch" ;;
 230                         esac
 231                 ) || die "Unable to checkout submodule '$path'"
 232         fi
 233
 234         git add "$path" ||
 235         die "Failed to add submodule '$path'"
 236
 237         git config -f .gitmodules submodule."$path".path "$path" &&
 238         git config -f .gitmodules submodule."$path".url "$repo" &&
 239         git add .gitmodules ||
 240         die "Failed to register submodule '$path'"
 241 }
 242
 243 #
 244 # Execute an arbitrary command sequence in each checked out
 245 # submodule
 246 #
 247 # $@ = command to execute
 248 #
 249 cmd_foreach()
 250 {
 251         module_list |
 252         while read mode sha1 stage path
 253         do
 254                 if test -e "$path"/.git
 255                 then
 256                         say "Entering '$path'"
 257                         (cd "$path" && eval "$@") ||
 258                         die "Stopping at '$path'; script returned non-zero status."
 259                 fi
 260         done
 261 }
 262
 263 #
 264 # Register submodules in .git/config
 265 #
 266 # $@ = requested paths (default to all)
 267 #
 268 cmd_init()
 269 {
 270         # parse $args after "submodule ... init".
 271         while test $# -ne 0
 272         do
 273                 case "$1" in
 274                 -q|--quiet)
 275                         quiet=1
 276                         ;;
 277                 --)
 278                         shift
 279                         break
 280                         ;;
 281                 -*)
 282                         usage
 283                         ;;
 284                 *)
 285                         break
 286                         ;;
 287                 esac
 288                 shift
 289         done
 290
 291         module_list "$@" |
 292         while read mode sha1 stage path
 293         do
 294                 # Skip already registered paths
 295                 name=$(module_name "$path") || exit
 296                 url=$(git config submodule."$name".url)
 297                 test -z "$url" || continue
 298
 299                 url=$(git config -f .gitmodules submodule."$name".url)
 300                 test -z "$url" &&
 301                 die "No url found for submodule path '$path' in .gitmodules"
 302
 303                 # Possibly a url relative to parent
 304                 case "$url" in
 305                 ./*|../*)
 306                         url=$(resolve_relative_url "$url") || exit
 307                         ;;
 308                 esac
 309
 310                 git config submodule."$name".url "$url" ||
 311                 die "Failed to register url for submodule path '$path'"
 312
 313                 say "Submodule '$name' ($url) registered for path '$path'"
 314         done
 315 }
 316
 317 #
 318 # Update each submodule path to correct revision, using clone and checkout as needed
 319 #
 320 # $@ = requested paths (default to all)
 321 #
 322 cmd_update()
 323 {
 324         # parse $args after "submodule ... update".
 325         while test $# -ne 0
 326         do
 327                 case "$1" in
 328                 -q|--quiet)
 329                         shift
 330                         quiet=1
 331                         ;;
 332                 -i|--init)
 333                         init=1
 334                         shift
 335                         ;;
 336                 -N|--no-fetch)
 337                         shift
 338                         nofetch=1
 339                         ;;
 340                 --reference)
 341                         case "$2" in '') usage ;; esac
 342                         reference="--reference=$2"
 343                         shift 2
 344                         ;;
 345                 --reference=*)
 346                         reference="$1"
 347                         shift
 348                         ;;
 349                 --)
 350                         shift
 351                         break
 352                         ;;
 353                 -*)
 354                         usage
 355                         ;;
 356                 *)
 357                         break
 358                         ;;
 359                 esac
 360         done
 361
 362         if test -n "$init"
 363         then
 364                 cmd_init "--" "$@" || return
 365         fi
 366
 367         module_list "$@" |
 368         while read mode sha1 stage path
 369         do
 370                 name=$(module_name "$path") || exit
 371                 url=$(git config submodule."$name".url)
 372                 if test -z "$url"
 373                 then
 374                         # Only mention uninitialized submodules when its
 375                         # path have been specified
 376                         test "$#" != "0" &&
 377                         say "Submodule path '$path' not initialized" &&
 378                         say "Maybe you want to use 'update --init'?"
 379                         continue
 380                 fi
 381
 382                 if ! test -d "$path"/.git -o -f "$path"/.git
 383                 then
 384                         module_clone "$path" "$url" "$reference"|| exit
 385                         subsha1=
 386                 else
 387                         subsha1=$(unset GIT_DIR; cd "$path" &&
 388                                 git rev-parse --verify HEAD) ||
 389                         die "Unable to find current revision in submodule path '$path'"
 390                 fi
 391
 392                 if test "$subsha1" != "$sha1"
 393                 then
 394                         force=
 395                         if test -z "$subsha1"
 396                         then
 397                                 force="-f"
 398                         fi
 399
 400                         if test -z "$nofetch"
 401                         then
 402                                 (unset GIT_DIR; cd "$path" &&
 403                                         git-fetch) ||
 404                                 die "Unable to fetch in submodule path '$path'"
 405                         fi
 406
 407                         (unset GIT_DIR; cd "$path" &&
 408                                   git-checkout $force -q "$sha1") ||
 409                         die "Unable to checkout '$sha1' in submodule path '$path'"
 410
 411                         say "Submodule path '$path': checked out '$sha1'"
 412                 fi
 413         done
 414 }
 415
 416 set_name_rev () {
 417         revname=$( (
 418                 unset GIT_DIR
 419                 cd "$1" && {
 420                         git describe "$2" 2>/dev/null ||
 421                         git describe --tags "$2" 2>/dev/null ||
 422                         git describe --contains "$2" 2>/dev/null ||
 423                         git describe --all --always "$2"
 424                 }
 425         ) )
 426         test -z "$revname" || revname=" ($revname)"
 427 }
 428 #
 429 # Show commit summary for submodules in index or working tree
 430 #
 431 # If '--cached' is given, show summary between index and given commit,
 432 # or between working tree and given commit
 433 #
 434 # $@ = [commit (default 'HEAD'),] requested paths (default all)
 435 #
 436 cmd_summary() {
 437         summary_limit=-1
 438         for_status=
 439
 440         # parse $args after "submodule ... summary".
 441         while test $# -ne 0
 442         do
 443                 case "$1" in
 444                 --cached)
 445                         cached="$1"
 446                         ;;
 447                 --for-status)
 448                         for_status="$1"
 449                         ;;
 450                 -n|--summary-limit)
 451                         if summary_limit=$(($2 + 0)) 2>/dev/null && test "$summary_limit" = "$2"
 452                         then
 453                                 :
 454                         else
 455                                 usage
 456                         fi
 457                         shift
 458                         ;;
 459                 --)
 460                         shift
 461                         break
 462                         ;;
 463                 -*)
 464                         usage
 465                         ;;
 466                 *)
 467                         break
 468                         ;;
 469                 esac
 470                 shift
 471         done
 472
 473         test $summary_limit = 0 && return
 474
 475         if rev=$(git rev-parse -q --verify "$1^0")
 476         then
 477                 head=$rev
 478                 shift
 479         else
 480                 head=HEAD
 481         fi
 482
 483         cd_to_toplevel
 484         # Get modified modules cared by user
 485         modules=$(git diff-index $cached --raw $head -- "$@" |
 486                 egrep '^:([0-7]* )?160000' |
 487                 while read mod_src mod_dst sha1_src sha1_dst status name
 488                 do
 489                         # Always show modules deleted or type-changed (blob<->module)
 490                         test $status = D -o $status = T && echo "$name" && continue
 491                         # Also show added or modified modules which are checked out
 492                         GIT_DIR="$name/.git" git-rev-parse --git-dir >/dev/null 2>&1 &&
 493                         echo "$name"
 494                 done
 495         )
 496
 497         test -z "$modules" && return
 498
 499         git diff-index $cached --raw $head -- $modules |
 500         egrep '^:([0-7]* )?160000' |
 501         cut -c2- |
 502         while read mod_src mod_dst sha1_src sha1_dst status name
 503         do
 504                 if test -z "$cached" &&
 505                         test $sha1_dst = 0000000000000000000000000000000000000000
 506                 then
 507                         case "$mod_dst" in
 508                         160000)
 509                                 sha1_dst=$(GIT_DIR="$name/.git" git rev-parse HEAD)
 510                                 ;;
 511                         100644 | 100755 | 120000)
 512                                 sha1_dst=$(git hash-object $name)
 513                                 ;;
 514                         000000)
 515                                 ;; # removed
 516                         *)
 517                                 # unexpected type
 518                                 echo >&2 "unexpected mode $mod_dst"
 519                                 continue ;;
 520                         esac
 521                 fi
 522                 missing_src=
 523                 missing_dst=
 524
 525                 test $mod_src = 160000 &&
 526                 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_src^0 >/dev/null &&
 527                 missing_src=t
 528
 529                 test $mod_dst = 160000 &&
 530                 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_dst^0 >/dev/null &&
 531                 missing_dst=t
 532
 533                 total_commits=
 534                 case "$missing_src,$missing_dst" in
 535                 t,)
 536                         errmsg="  Warn: $name doesn't contain commit $sha1_src"
 537                         ;;
 538                 ,t)
 539                         errmsg="  Warn: $name doesn't contain commit $sha1_dst"
 540                         ;;
 541                 t,t)
 542                         errmsg="  Warn: $name doesn't contain commits $sha1_src and $sha1_dst"
 543                         ;;
 544                 *)
 545                         errmsg=
 546                         total_commits=$(
 547                         if test $mod_src = 160000 -a $mod_dst = 160000
 548                         then
 549                                 range="$sha1_src...$sha1_dst"
 550                         elif test $mod_src = 160000
 551                         then
 552                                 range=$sha1_src
 553                         else
 554                                 range=$sha1_dst
 555                         fi
 556                         GIT_DIR="$name/.git" \
 557                         git log --pretty=oneline --first-parent $range | wc -l
 558                         )
 559                         total_commits=" ($(($total_commits + 0)))"
 560                         ;;
 561                 esac
 562
 563                 sha1_abbr_src=$(echo $sha1_src | cut -c1-7)
 564                 sha1_abbr_dst=$(echo $sha1_dst | cut -c1-7)
 565                 if test $status = T
 566                 then
 567                         if test $mod_dst = 160000
 568                         then
 569                                 echo "* $name $sha1_abbr_src(blob)->$sha1_abbr_dst(submodule)$total_commits:"
 570                         else
 571                                 echo "* $name $sha1_abbr_src(submodule)->$sha1_abbr_dst(blob)$total_commits:"
 572                         fi
 573                 else
 574                         echo "* $name $sha1_abbr_src...$sha1_abbr_dst$total_commits:"
 575                 fi
 576                 if test -n "$errmsg"
 577                 then
 578                         # Don't give error msg for modification whose dst is not submodule
 579                         # i.e. deleted or changed to blob
 580                         test $mod_dst = 160000 && echo "$errmsg"
 581                 else
 582                         if test $mod_src = 160000 -a $mod_dst = 160000
 583                         then
 584                                 limit=
 585                                 test $summary_limit -gt 0 && limit="-$summary_limit"
 586                                 GIT_DIR="$name/.git" \
 587                                 git log $limit --pretty='format:  %m %s' \
 588                                 --first-parent $sha1_src...$sha1_dst
 589                         elif test $mod_dst = 160000
 590                         then
 591                                 GIT_DIR="$name/.git" \
 592                                 git log --pretty='format:  > %s' -1 $sha1_dst
 593                         else
 594                                 GIT_DIR="$name/.git" \
 595                                 git log --pretty='format:  < %s' -1 $sha1_src
 596                         fi
 597                         echo
 598                 fi
 599                 echo
 600         done |
 601         if test -n "$for_status"; then
 602                 echo "# Modified submodules:"
 603                 echo "#"
 604                 sed -e 's|^|# |' -e 's|^# $|#|'
 605         else
 606                 cat
 607         fi
 608 }
 609 #
 610 # List all submodules, prefixed with:
 611 #  - submodule not initialized
 612 #  + different revision checked out
 613 #
 614 # If --cached was specified the revision in the index will be printed
 615 # instead of the currently checked out revision.
 616 #
 617 # $@ = requested paths (default to all)
 618 #
 619 cmd_status()
 620 {
 621         # parse $args after "submodule ... status".
 622         while test $# -ne 0
 623         do
 624                 case "$1" in
 625                 -q|--quiet)
 626                         quiet=1
 627                         ;;
 628                 --cached)
 629                         cached=1
 630                         ;;
 631                 --)
 632                         shift
 633                         break
 634                         ;;
 635                 -*)
 636                         usage
 637                         ;;
 638                 *)
 639                         break
 640                         ;;
 641                 esac
 642                 shift
 643         done
 644
 645         module_list "$@" |
 646         while read mode sha1 stage path
 647         do
 648                 name=$(module_name "$path") || exit
 649                 url=$(git config submodule."$name".url)
 650                 if test -z "$url" || ! test -d "$path"/.git -o -f "$path"/.git
 651                 then
 652                         say "-$sha1 $path"
 653                         continue;
 654                 fi
 655                 set_name_rev "$path" "$sha1"
 656                 if git diff-files --quiet -- "$path"
 657                 then
 658                         say " $sha1 $path$revname"
 659                 else
 660                         if test -z "$cached"
 661                         then
 662                                 sha1=$(unset GIT_DIR; cd "$path" && git rev-parse --verify HEAD)
 663                                 set_name_rev "$path" "$sha1"
 664                         fi
 665                         say "+$sha1 $path$revname"
 666                 fi
 667         done
 668 }
 669 #
 670 # Sync remote urls for submodules
 671 # This makes the value for remote.$remote.url match the value
 672 # specified in .gitmodules.
 673 #
 674 cmd_sync()
 675 {
 676         while test $# -ne 0
 677         do
 678                 case "$1" in
 679                 -q|--quiet)
 680                         quiet=1
 681                         shift
 682                         ;;
 683                 --)
 684                         shift
 685                         break
 686                         ;;
 687                 -*)
 688                         usage
 689                         ;;
 690                 *)
 691                         break
 692                         ;;
 693                 esac
 694         done
 695         cd_to_toplevel
 696         module_list "$@" |
 697         while read mode sha1 stage path
 698         do
 699                 name=$(module_name "$path")
 700                 url=$(git config -f .gitmodules --get submodule."$name".url)
 701
 702                 # Possibly a url relative to parent
 703                 case "$url" in
 704                 ./*|../*)
 705                         url=$(resolve_relative_url "$url") || exit
 706                         ;;
 707                 esac
 708
 709                 if test -e "$path"/.git
 710                 then
 711                 (
 712                         unset GIT_DIR
 713                         cd "$path"
 714                         remote=$(get_default_remote)
 715                         say "Synchronizing submodule url for '$name'"
 716                         git config remote."$remote".url "$url"
 717                 )
 718                 fi
 719         done
 720 }
 721
 722 # This loop parses the command line arguments to find the
 723 # subcommand name to dispatch.  Parsing of the subcommand specific
 724 # options are primarily done by the subcommand implementations.
 725 # Subcommand specific options such as --branch and --cached are
 726 # parsed here as well, for backward compatibility.
 727
 728 while test $# != 0 && test -z "$command"
 729 do
 730         case "$1" in
 731         add | foreach | init | update | status | summary | sync)
 732                 command=$1
 733                 ;;
 734         -q|--quiet)
 735                 quiet=1
 736                 ;;
 737         -b|--branch)
 738                 case "$2" in
 739                 '')
 740                         usage
 741                         ;;
 742                 esac
 743                 branch="$2"; shift
 744                 ;;
 745         --cached)
 746                 cached="$1"
 747                 ;;
 748         --)
 749                 break
 750                 ;;
 751         -*)
 752                 usage
 753                 ;;
 754         *)
 755                 break
 756                 ;;
 757         esac
 758         shift
 759 done
 760
 761 # No command word defaults to "status"
 762 test -n "$command" || command=status
 763
 764 # "-b branch" is accepted only by "add"
 765 if test -n "$branch" && test "$command" != add
 766 then
 767         usage
 768 fi
 769
 770 # "--cached" is accepted only by "status" and "summary"
 771 if test -n "$cached" && test "$command" != status -a "$command" != summary
 772 then
 773         usage
 774 fi
 775
 776 "cmd_$command" "$@"