git-submodule.sh

   1 #!/bin/sh
   2 #
   3 # git-submodule.sh: add, init, update or list git submodules
   4 #
   5 # Copyright (c) 2007 Lars Hjemli
   6
   7 dashless=$(basename "$0" | sed -e 's/-/ /')
   8 USAGE="[--quiet] add [-b <branch>] [-f|--force] [--name <name>] [--reference <repository>] [--] <repository> [<path>]
   9    or: $dashless [--quiet] status [--cached] [--recursive] [--] [<path>...]
  10    or: $dashless [--quiet] init [--] [<path>...]
  11    or: $dashless [--quiet] deinit [-f|--force] (--all| [--] <path>...)
  12    or: $dashless [--quiet] update [--init] [--remote] [-N|--no-fetch] [-f|--force] [--checkout|--merge|--rebase] [--[no-]recommend-shallow] [--reference <repository>] [--recursive] [--] [<path>...]
  13    or: $dashless [--quiet] summary [--cached|--files] [--summary-limit <n>] [commit] [--] [<path>...]
  14    or: $dashless [--quiet] foreach [--recursive] <command>
  15    or: $dashless [--quiet] sync [--recursive] [--] [<path>...]"
  16 OPTIONS_SPEC=
  17 SUBDIRECTORY_OK=Yes
  18 . git-sh-setup
  19 . git-parse-remote
  20 require_work_tree
  21 wt_prefix=$(git rev-parse --show-prefix)
  22 cd_to_toplevel
  23
  24 # Restrict ourselves to a vanilla subset of protocols; the URLs
  25 # we get are under control of a remote repository, and we do not
  26 # want them kicking off arbitrary git-remote-* programs.
  27 #
  28 # If the user has already specified a set of allowed protocols,
  29 # we assume they know what they're doing and use that instead.
  30 : ${GIT_ALLOW_PROTOCOL=file:git:http:https:ssh}
  31 export GIT_ALLOW_PROTOCOL
  32
  33 command=
  34 branch=
  35 force=
  36 reference=
  37 cached=
  38 recursive=
  39 init=
  40 files=
  41 remote=
  42 nofetch=
  43 update=
  44 prefix=
  45 custom_name=
  46 depth=
  47
  48 die_if_unmatched ()
  49 {
  50         if test "$1" = "#unmatched"
  51         then
  52                 exit ${2:-1}
  53         fi
  54 }
  55
  56 #
  57 # Print a submodule configuration setting
  58 #
  59 # $1 = submodule name
  60 # $2 = option name
  61 # $3 = default value
  62 #
  63 # Checks in the usual git-config places first (for overrides),
  64 # otherwise it falls back on .gitmodules.  This allows you to
  65 # distribute project-wide defaults in .gitmodules, while still
  66 # customizing individual repositories if necessary.  If the option is
  67 # not in .gitmodules either, print a default value.
  68 #
  69 get_submodule_config () {
  70         name="$1"
  71         option="$2"
  72         default="$3"
  73         value=$(git config submodule."$name"."$option")
  74         if test -z "$value"
  75         then
  76                 value=$(git config -f .gitmodules submodule."$name"."$option")
  77         fi
  78         printf '%s' "${value:-$default}"
  79 }
  80
  81 isnumber()
  82 {
  83         n=$(($1 + 0)) 2>/dev/null && test "$n" = "$1"
  84 }
  85
  86 # Sanitize the local git environment for use within a submodule. We
  87 # can't simply use clear_local_git_env since we want to preserve some
  88 # of the settings from GIT_CONFIG_PARAMETERS.
  89 sanitize_submodule_env()
  90 {
  91         save_config=$GIT_CONFIG_PARAMETERS
  92         clear_local_git_env
  93         GIT_CONFIG_PARAMETERS=$save_config
  94         export GIT_CONFIG_PARAMETERS
  95 }
  96
  97 #
  98 # Add a new submodule to the working tree, .gitmodules and the index
  99 #
 100 # $@ = repo path
 101 #
 102 # optional branch is stored in global branch variable
 103 #
 104 cmd_add()
 105 {
 106         # parse $args after "submodule ... add".
 107         reference_path=
 108         while test $# -ne 0
 109         do
 110                 case "$1" in
 111                 -b | --branch)
 112                         case "$2" in '') usage ;; esac
 113                         branch=$2
 114                         shift
 115                         ;;
 116                 -f | --force)
 117                         force=$1
 118                         ;;
 119                 -q|--quiet)
 120                         GIT_QUIET=1
 121                         ;;
 122                 --reference)
 123                         case "$2" in '') usage ;; esac
 124                         reference_path=$2
 125                         shift
 126                         ;;
 127                 --reference=*)
 128                         reference_path="${1#--reference=}"
 129                         ;;
 130                 --name)
 131                         case "$2" in '') usage ;; esac
 132                         custom_name=$2
 133                         shift
 134                         ;;
 135                 --depth)
 136                         case "$2" in '') usage ;; esac
 137                         depth="--depth=$2"
 138                         shift
 139                         ;;
 140                 --depth=*)
 141                         depth=$1
 142                         ;;
 143                 --)
 144                         shift
 145                         break
 146                         ;;
 147                 -*)
 148                         usage
 149                         ;;
 150                 *)
 151                         break
 152                         ;;
 153                 esac
 154                 shift
 155         done
 156
 157         if test -n "$reference_path"
 158         then
 159                 is_absolute_path "$reference_path" ||
 160                 reference_path="$wt_prefix$reference_path"
 161
 162                 reference="--reference=$reference_path"
 163         fi
 164
 165         repo=$1
 166         sm_path=$2
 167
 168         if test -z "$sm_path"; then
 169                 sm_path=$(printf '%s\n' "$repo" |
 170                         sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
 171         fi
 172
 173         if test -z "$repo" || test -z "$sm_path"; then
 174                 usage
 175         fi
 176
 177         is_absolute_path "$sm_path" || sm_path="$wt_prefix$sm_path"
 178
 179         # assure repo is absolute or relative to parent
 180         case "$repo" in
 181         ./*|../*)
 182                 test -z "$wt_prefix" ||
 183                 die "$(gettext "Relative path can only be used from the toplevel of the working tree")"
 184
 185                 # dereference source url relative to parent's url
 186                 realrepo=$(git submodule--helper resolve-relative-url "$repo") || exit
 187                 ;;
 188         *:*|/*)
 189                 # absolute url
 190                 realrepo=$repo
 191                 ;;
 192         *)
 193                 die "$(eval_gettext "repo URL: '\$repo' must be absolute or begin with ./|../")"
 194         ;;
 195         esac
 196
 197         # normalize path:
 198         # multiple //; leading ./; /./; /../; trailing /
 199         sm_path=$(printf '%s/\n' "$sm_path" |
 200                 sed -e '
 201                         s|//*|/|g
 202                         s|^\(\./\)*||
 203                         s|/\(\./\)*|/|g
 204                         :start
 205                         s|\([^/]*\)/\.\./||
 206                         tstart
 207                         s|/*$||
 208                 ')
 209         git ls-files --error-unmatch "$sm_path" > /dev/null 2>&1 &&
 210         die "$(eval_gettext "'\$sm_path' already exists in the index")"
 211
 212         if test -z "$force" && ! git add --dry-run --ignore-missing "$sm_path" > /dev/null 2>&1
 213         then
 214                 eval_gettextln "The following path is ignored by one of your .gitignore files:
 215 \$sm_path
 216 Use -f if you really want to add it." >&2
 217                 exit 1
 218         fi
 219
 220         if test -n "$custom_name"
 221         then
 222                 sm_name="$custom_name"
 223         else
 224                 sm_name="$sm_path"
 225         fi
 226
 227         # perhaps the path exists and is already a git repo, else clone it
 228         if test -e "$sm_path"
 229         then
 230                 if test -d "$sm_path"/.git || test -f "$sm_path"/.git
 231                 then
 232                         eval_gettextln "Adding existing repo at '\$sm_path' to the index"
 233                 else
 234                         die "$(eval_gettext "'\$sm_path' already exists and is not a valid git repo")"
 235                 fi
 236
 237         else
 238                 if test -d ".git/modules/$sm_name"
 239                 then
 240                         if test -z "$force"
 241                         then
 242                                 eval_gettextln >&2 "A git directory for '\$sm_name' is found locally with remote(s):"
 243                                 GIT_DIR=".git/modules/$sm_name" GIT_WORK_TREE=. git remote -v | grep '(fetch)' | sed -e s,^,"  ", -e s,' (fetch)',, >&2
 244                                 die "$(eval_gettextln "\
 245 If you want to reuse this local git directory instead of cloning again from
 246   \$realrepo
 247 use the '--force' option. If the local git directory is not the correct repo
 248 or you are unsure what this means choose another name with the '--name' option.")"
 249                         else
 250                                 eval_gettextln "Reactivating local git directory for submodule '\$sm_name'."
 251                         fi
 252                 fi
 253                 git submodule--helper clone ${GIT_QUIET:+--quiet} --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" ${reference:+"$reference"} ${depth:+"$depth"} || exit
 254                 (
 255                         sanitize_submodule_env
 256                         cd "$sm_path" &&
 257                         # ash fails to wordsplit ${branch:+-b "$branch"...}
 258                         case "$branch" in
 259                         '') git checkout -f -q ;;
 260                         ?*) git checkout -f -q -B "$branch" "origin/$branch" ;;
 261                         esac
 262                 ) || die "$(eval_gettext "Unable to checkout submodule '\$sm_path'")"
 263         fi
 264         git config submodule."$sm_name".url "$realrepo"
 265
 266         git add $force "$sm_path" ||
 267         die "$(eval_gettext "Failed to add submodule '\$sm_path'")"
 268
 269         git config -f .gitmodules submodule."$sm_name".path "$sm_path" &&
 270         git config -f .gitmodules submodule."$sm_name".url "$repo" &&
 271         if test -n "$branch"
 272         then
 273                 git config -f .gitmodules submodule."$sm_name".branch "$branch"
 274         fi &&
 275         git add --force .gitmodules ||
 276         die "$(eval_gettext "Failed to register submodule '\$sm_path'")"
 277 }
 278
 279 #
 280 # Execute an arbitrary command sequence in each checked out
 281 # submodule
 282 #
 283 # $@ = command to execute
 284 #
 285 cmd_foreach()
 286 {
 287         # parse $args after "submodule ... foreach".
 288         while test $# -ne 0
 289         do
 290                 case "$1" in
 291                 -q|--quiet)
 292                         GIT_QUIET=1
 293                         ;;
 294                 --recursive)
 295                         recursive=1
 296                         ;;
 297                 -*)
 298                         usage
 299                         ;;
 300                 *)
 301                         break
 302                         ;;
 303                 esac
 304                 shift
 305         done
 306
 307         toplevel=$(pwd)
 308
 309         # dup stdin so that it can be restored when running the external
 310         # command in the subshell (and a recursive call to this function)
 311         exec 3<&0
 312
 313         {
 314                 git submodule--helper list --prefix "$wt_prefix" ||
 315                 echo "#unmatched" $?
 316         } |
 317         while read mode sha1 stage sm_path
 318         do
 319                 die_if_unmatched "$mode" "$sha1"
 320                 if test -e "$sm_path"/.git
 321                 then
 322                         displaypath=$(git submodule--helper relative-path "$prefix$sm_path" "$wt_prefix")
 323                         say "$(eval_gettext "Entering '\$displaypath'")"
 324                         name=$(git submodule--helper name "$sm_path")
 325                         (
 326                                 prefix="$prefix$sm_path/"
 327                                 sanitize_submodule_env
 328                                 cd "$sm_path" &&
 329                                 sm_path=$(git submodule--helper relative-path "$sm_path" "$wt_prefix") &&
 330                                 # we make $path available to scripts ...
 331                                 path=$sm_path &&
 332                                 if test $# -eq 1
 333                                 then
 334                                         eval "$1"
 335                                 else
 336                                         "$@"
 337                                 fi &&
 338                                 if test -n "$recursive"
 339                                 then
 340                                         cmd_foreach "--recursive" "$@"
 341                                 fi
 342                         ) <&3 3<&- ||
 343                         die "$(eval_gettext "Stopping at '\$displaypath'; script returned non-zero status.")"
 344                 fi
 345         done
 346 }
 347
 348 #
 349 # Register submodules in .git/config
 350 #
 351 # $@ = requested paths (default to all)
 352 #
 353 cmd_init()
 354 {
 355         # parse $args after "submodule ... init".
 356         while test $# -ne 0
 357         do
 358                 case "$1" in
 359                 -q|--quiet)
 360                         GIT_QUIET=1
 361                         ;;
 362                 --)
 363                         shift
 364                         break
 365                         ;;
 366                 -*)
 367                         usage
 368                         ;;
 369                 *)
 370                         break
 371                         ;;
 372                 esac
 373                 shift
 374         done
 375
 376         git ${wt_prefix:+-C "$wt_prefix"} submodule--helper init ${GIT_QUIET:+--quiet} ${prefix:+--prefix "$prefix"} "$@"
 377 }
 378
 379 #
 380 # Unregister submodules from .git/config and remove their work tree
 381 #
 382 cmd_deinit()
 383 {
 384         # parse $args after "submodule ... deinit".
 385         deinit_all=
 386         while test $# -ne 0
 387         do
 388                 case "$1" in
 389                 -f|--force)
 390                         force=$1
 391                         ;;
 392                 -q|--quiet)
 393                         GIT_QUIET=1
 394                         ;;
 395                 --all)
 396                         deinit_all=t
 397                         ;;
 398                 --)
 399                         shift
 400                         break
 401                         ;;
 402                 -*)
 403                         usage
 404                         ;;
 405                 *)
 406                         break
 407                         ;;
 408                 esac
 409                 shift
 410         done
 411
 412         if test -n "$deinit_all" && test "$#" -ne 0
 413         then
 414                 echo >&2 "$(eval_gettext "pathspec and --all are incompatible")"
 415                 usage
 416         fi
 417         if test $# = 0 && test -z "$deinit_all"
 418         then
 419                 die "$(eval_gettext "Use '--all' if you really want to deinitialize all submodules")"
 420         fi
 421
 422         {
 423                 git submodule--helper list --prefix "$wt_prefix" "$@" ||
 424                 echo "#unmatched" $?
 425         } |
 426         while read mode sha1 stage sm_path
 427         do
 428                 die_if_unmatched "$mode" "$sha1"
 429                 name=$(git submodule--helper name "$sm_path") || exit
 430
 431                 displaypath=$(git submodule--helper relative-path "$sm_path" "$wt_prefix")
 432
 433                 # Remove the submodule work tree (unless the user already did it)
 434                 if test -d "$sm_path"
 435                 then
 436                         # Protect submodules containing a .git directory
 437                         if test -d "$sm_path/.git"
 438                         then
 439                                 die "$(eval_gettext "\
 440 Submodule work tree '\$displaypath' contains a .git directory
 441 (use 'rm -rf' if you really want to remove it including all of its history)")"
 442                         fi
 443
 444                         if test -z "$force"
 445                         then
 446                                 git rm -qn "$sm_path" ||
 447                                 die "$(eval_gettext "Submodule work tree '\$displaypath' contains local modifications; use '-f' to discard them")"
 448                         fi
 449                         rm -rf "$sm_path" &&
 450                         say "$(eval_gettext "Cleared directory '\$displaypath'")" ||
 451                         say "$(eval_gettext "Could not remove submodule work tree '\$displaypath'")"
 452                 fi
 453
 454                 mkdir "$sm_path" || say "$(eval_gettext "Could not create empty submodule directory '\$displaypath'")"
 455
 456                 # Remove the .git/config entries (unless the user already did it)
 457                 if test -n "$(git config --get-regexp submodule."$name\.")"
 458                 then
 459                         # Remove the whole section so we have a clean state when
 460                         # the user later decides to init this submodule again
 461                         url=$(git config submodule."$name".url)
 462                         git config --remove-section submodule."$name" 2>/dev/null &&
 463                         say "$(eval_gettext "Submodule '\$name' (\$url) unregistered for path '\$displaypath'")"
 464                 fi
 465         done
 466 }
 467
 468 is_tip_reachable () (
 469         sanitize_submodule_env &&
 470         cd "$1" &&
 471         rev=$(git rev-list -n 1 "$2" --not --all 2>/dev/null) &&
 472         test -z "$rev"
 473 )
 474
 475 fetch_in_submodule () (
 476         sanitize_submodule_env &&
 477         cd "$1" &&
 478         case "$2" in
 479         '')
 480                 git fetch ;;
 481         *)
 482                 git fetch $(get_default_remote) "$2" ;;
 483         esac
 484 )
 485
 486 #
 487 # Update each submodule path to correct revision, using clone and checkout as needed
 488 #
 489 # $@ = requested paths (default to all)
 490 #
 491 cmd_update()
 492 {
 493         # parse $args after "submodule ... update".
 494         while test $# -ne 0
 495         do
 496                 case "$1" in
 497                 -q|--quiet)
 498                         GIT_QUIET=1
 499                         ;;
 500                 -i|--init)
 501                         init=1
 502                         ;;
 503                 --remote)
 504                         remote=1
 505                         ;;
 506                 -N|--no-fetch)
 507                         nofetch=1
 508                         ;;
 509                 -f|--force)
 510                         force=$1
 511                         ;;
 512                 -r|--rebase)
 513                         update="rebase"
 514                         ;;
 515                 --reference)
 516                         case "$2" in '') usage ;; esac
 517                         reference="--reference=$2"
 518                         shift
 519                         ;;
 520                 --reference=*)
 521                         reference="$1"
 522                         ;;
 523                 -m|--merge)
 524                         update="merge"
 525                         ;;
 526                 --recursive)
 527                         recursive=1
 528                         ;;
 529                 --checkout)
 530                         update="checkout"
 531                         ;;
 532                 --recommend-shallow)
 533                         recommend_shallow="--recommend-shallow"
 534                         ;;
 535                 --no-recommend-shallow)
 536                         recommend_shallow="--no-recommend-shallow"
 537                         ;;
 538                 --depth)
 539                         case "$2" in '') usage ;; esac
 540                         depth="--depth=$2"
 541                         shift
 542                         ;;
 543                 --depth=*)
 544                         depth=$1
 545                         ;;
 546                 -j|--jobs)
 547                         case "$2" in '') usage ;; esac
 548                         jobs="--jobs=$2"
 549                         shift
 550                         ;;
 551                 --jobs=*)
 552                         jobs=$1
 553                         ;;
 554                 --)
 555                         shift
 556                         break
 557                         ;;
 558                 -*)
 559                         usage
 560                         ;;
 561                 *)
 562                         break
 563                         ;;
 564                 esac
 565                 shift
 566         done
 567
 568         if test -n "$init"
 569         then
 570                 cmd_init "--" "$@" || return
 571         fi
 572
 573         {
 574         git submodule--helper update-clone ${GIT_QUIET:+--quiet} \
 575                 ${wt_prefix:+--prefix "$wt_prefix"} \
 576                 ${prefix:+--recursive-prefix "$prefix"} \
 577                 ${update:+--update "$update"} \
 578                 ${reference:+--reference "$reference"} \
 579                 ${depth:+--depth "$depth"} \
 580                 ${recommend_shallow:+"$recommend_shallow"} \
 581                 ${jobs:+$jobs} \
 582                 "$@" || echo "#unmatched" $?
 583         } | {
 584         err=
 585         while read mode sha1 stage just_cloned sm_path
 586         do
 587                 die_if_unmatched "$mode" "$sha1"
 588
 589                 name=$(git submodule--helper name "$sm_path") || exit
 590                 url=$(git config submodule."$name".url)
 591                 branch=$(get_submodule_config "$name" branch master)
 592                 if ! test -z "$update"
 593                 then
 594                         update_module=$update
 595                 else
 596                         update_module=$(git config submodule."$name".update)
 597                         if test -z "$update_module"
 598                         then
 599                                 update_module="checkout"
 600                         fi
 601                 fi
 602
 603                 displaypath=$(git submodule--helper relative-path "$prefix$sm_path" "$wt_prefix")
 604
 605                 if test $just_cloned -eq 1
 606                 then
 607                         subsha1=
 608                         update_module=checkout
 609                 else
 610                         subsha1=$(sanitize_submodule_env; cd "$sm_path" &&
 611                                 git rev-parse --verify HEAD) ||
 612                         die "$(eval_gettext "Unable to find current revision in submodule path '\$displaypath'")"
 613                 fi
 614
 615                 if test -n "$remote"
 616                 then
 617                         if test -z "$nofetch"
 618                         then
 619                                 # Fetch remote before determining tracking $sha1
 620                                 fetch_in_submodule "$sm_path" ||
 621                                 die "$(eval_gettext "Unable to fetch in submodule path '\$sm_path'")"
 622                         fi
 623                         remote_name=$(sanitize_submodule_env; cd "$sm_path" && get_default_remote)
 624                         sha1=$(sanitize_submodule_env; cd "$sm_path" &&
 625                                 git rev-parse --verify "${remote_name}/${branch}") ||
 626                         die "$(eval_gettext "Unable to find current \${remote_name}/\${branch} revision in submodule path '\$sm_path'")"
 627                 fi
 628
 629                 if test "$subsha1" != "$sha1" || test -n "$force"
 630                 then
 631                         subforce=$force
 632                         # If we don't already have a -f flag and the submodule has never been checked out
 633                         if test -z "$subsha1" && test -z "$force"
 634                         then
 635                                 subforce="-f"
 636                         fi
 637
 638                         if test -z "$nofetch"
 639                         then
 640                                 # Run fetch only if $sha1 isn't present or it
 641                                 # is not reachable from a ref.
 642                                 is_tip_reachable "$sm_path" "$sha1" ||
 643                                 fetch_in_submodule "$sm_path" ||
 644                                 die "$(eval_gettext "Unable to fetch in submodule path '\$displaypath'")"
 645
 646                                 # Now we tried the usual fetch, but $sha1 may
 647                                 # not be reachable from any of the refs
 648                                 is_tip_reachable "$sm_path" "$sha1" ||
 649                                 fetch_in_submodule "$sm_path" "$sha1" ||
 650                                 die "$(eval_gettext "Fetched in submodule path '\$displaypath', but it did not contain \$sha1. Direct fetching of that commit failed.")"
 651                         fi
 652
 653                         must_die_on_failure=
 654                         case "$update_module" in
 655                         checkout)
 656                                 command="git checkout $subforce -q"
 657                                 die_msg="$(eval_gettext "Unable to checkout '\$sha1' in submodule path '\$displaypath'")"
 658                                 say_msg="$(eval_gettext "Submodule path '\$displaypath': checked out '\$sha1'")"
 659                                 ;;
 660                         rebase)
 661                                 command="git rebase"
 662                                 die_msg="$(eval_gettext "Unable to rebase '\$sha1' in submodule path '\$displaypath'")"
 663                                 say_msg="$(eval_gettext "Submodule path '\$displaypath': rebased into '\$sha1'")"
 664                                 must_die_on_failure=yes
 665                                 ;;
 666                         merge)
 667                                 command="git merge"
 668                                 die_msg="$(eval_gettext "Unable to merge '\$sha1' in submodule path '\$displaypath'")"
 669                                 say_msg="$(eval_gettext "Submodule path '\$displaypath': merged in '\$sha1'")"
 670                                 must_die_on_failure=yes
 671                                 ;;
 672                         !*)
 673                                 command="${update_module#!}"
 674                                 die_msg="$(eval_gettext "Execution of '\$command \$sha1' failed in submodule path '\$displaypath'")"
 675                                 say_msg="$(eval_gettext "Submodule path '\$displaypath': '\$command \$sha1'")"
 676                                 must_die_on_failure=yes
 677                                 ;;
 678                         *)
 679                                 die "$(eval_gettext "Invalid update mode '$update_module' for submodule '$name'")"
 680                         esac
 681
 682                         if (sanitize_submodule_env; cd "$sm_path" && $command "$sha1")
 683                         then
 684                                 say "$say_msg"
 685                         elif test -n "$must_die_on_failure"
 686                         then
 687                                 die_with_status 2 "$die_msg"
 688                         else
 689                                 err="${err};$die_msg"
 690                                 continue
 691                         fi
 692                 fi
 693
 694                 if test -n "$recursive"
 695                 then
 696                         (
 697                                 prefix=$(git submodule--helper relative-path "$prefix$sm_path/" "$wt_prefix")
 698                                 wt_prefix=
 699                                 sanitize_submodule_env
 700                                 cd "$sm_path" &&
 701                                 eval cmd_update
 702                         )
 703                         res=$?
 704                         if test $res -gt 0
 705                         then
 706                                 die_msg="$(eval_gettext "Failed to recurse into submodule path '\$displaypath'")"
 707                                 if test $res -ne 2
 708                                 then
 709                                         err="${err};$die_msg"
 710                                         continue
 711                                 else
 712                                         die_with_status $res "$die_msg"
 713                                 fi
 714                         fi
 715                 fi
 716         done
 717
 718         if test -n "$err"
 719         then
 720                 OIFS=$IFS
 721                 IFS=';'
 722                 for e in $err
 723                 do
 724                         if test -n "$e"
 725                         then
 726                                 echo >&2 "$e"
 727                         fi
 728                 done
 729                 IFS=$OIFS
 730                 exit 1
 731         fi
 732         }
 733 }
 734
 735 set_name_rev () {
 736         revname=$( (
 737                 sanitize_submodule_env
 738                 cd "$1" && {
 739                         git describe "$2" 2>/dev/null ||
 740                         git describe --tags "$2" 2>/dev/null ||
 741                         git describe --contains "$2" 2>/dev/null ||
 742                         git describe --all --always "$2"
 743                 }
 744         ) )
 745         test -z "$revname" || revname=" ($revname)"
 746 }
 747 #
 748 # Show commit summary for submodules in index or working tree
 749 #
 750 # If '--cached' is given, show summary between index and given commit,
 751 # or between working tree and given commit
 752 #
 753 # $@ = [commit (default 'HEAD'),] requested paths (default all)
 754 #
 755 cmd_summary() {
 756         summary_limit=-1
 757         for_status=
 758         diff_cmd=diff-index
 759
 760         # parse $args after "submodule ... summary".
 761         while test $# -ne 0
 762         do
 763                 case "$1" in
 764                 --cached)
 765                         cached="$1"
 766                         ;;
 767                 --files)
 768                         files="$1"
 769                         ;;
 770                 --for-status)
 771                         for_status="$1"
 772                         ;;
 773                 -n|--summary-limit)
 774                         summary_limit="$2"
 775                         isnumber "$summary_limit" || usage
 776                         shift
 777                         ;;
 778                 --summary-limit=*)
 779                         summary_limit="${1#--summary-limit=}"
 780                         isnumber "$summary_limit" || usage
 781                         ;;
 782                 --)
 783                         shift
 784                         break
 785                         ;;
 786                 -*)
 787                         usage
 788                         ;;
 789                 *)
 790                         break
 791                         ;;
 792                 esac
 793                 shift
 794         done
 795
 796         test $summary_limit = 0 && return
 797
 798         if rev=$(git rev-parse -q --verify --default HEAD ${1+"$1"})
 799         then
 800                 head=$rev
 801                 test $# = 0 || shift
 802         elif test -z "$1" || test "$1" = "HEAD"
 803         then
 804                 # before the first commit: compare with an empty tree
 805                 head=$(git hash-object -w -t tree --stdin </dev/null)
 806                 test -z "$1" || shift
 807         else
 808                 head="HEAD"
 809         fi
 810
 811         if [ -n "$files" ]
 812         then
 813                 test -n "$cached" &&
 814                 die "$(gettext "The --cached option cannot be used with the --files option")"
 815                 diff_cmd=diff-files
 816                 head=
 817         fi
 818
 819         cd_to_toplevel
 820         eval "set $(git rev-parse --sq --prefix "$wt_prefix" -- "$@")"
 821         # Get modified modules cared by user
 822         modules=$(git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- "$@" |
 823                 sane_egrep '^:([0-7]* )?160000' |
 824                 while read mod_src mod_dst sha1_src sha1_dst status sm_path
 825                 do
 826                         # Always show modules deleted or type-changed (blob<->module)
 827                         if test "$status" = D || test "$status" = T
 828                         then
 829                                 printf '%s\n' "$sm_path"
 830                                 continue
 831                         fi
 832                         # Respect the ignore setting for --for-status.
 833                         if test -n "$for_status"
 834                         then
 835                                 name=$(git submodule--helper name "$sm_path")
 836                                 ignore_config=$(get_submodule_config "$name" ignore none)
 837                                 test $status != A && test $ignore_config = all && continue
 838                         fi
 839                         # Also show added or modified modules which are checked out
 840                         GIT_DIR="$sm_path/.git" git-rev-parse --git-dir >/dev/null 2>&1 &&
 841                         printf '%s\n' "$sm_path"
 842                 done
 843         )
 844
 845         test -z "$modules" && return
 846
 847         git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- $modules |
 848         sane_egrep '^:([0-7]* )?160000' |
 849         cut -c2- |
 850         while read mod_src mod_dst sha1_src sha1_dst status name
 851         do
 852                 if test -z "$cached" &&
 853                         test $sha1_dst = 0000000000000000000000000000000000000000
 854                 then
 855                         case "$mod_dst" in
 856                         160000)
 857                                 sha1_dst=$(GIT_DIR="$name/.git" git rev-parse HEAD)
 858                                 ;;
 859                         100644 | 100755 | 120000)
 860                                 sha1_dst=$(git hash-object $name)
 861                                 ;;
 862                         000000)
 863                                 ;; # removed
 864                         *)
 865                                 # unexpected type
 866                                 eval_gettextln "unexpected mode \$mod_dst" >&2
 867                                 continue ;;
 868                         esac
 869                 fi
 870                 missing_src=
 871                 missing_dst=
 872
 873                 test $mod_src = 160000 &&
 874                 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_src^0 >/dev/null &&
 875                 missing_src=t
 876
 877                 test $mod_dst = 160000 &&
 878                 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_dst^0 >/dev/null &&
 879                 missing_dst=t
 880
 881                 display_name=$(git submodule--helper relative-path "$name" "$wt_prefix")
 882
 883                 total_commits=
 884                 case "$missing_src,$missing_dst" in
 885                 t,)
 886                         errmsg="$(eval_gettext "  Warn: \$display_name doesn't contain commit \$sha1_src")"
 887                         ;;
 888                 ,t)
 889                         errmsg="$(eval_gettext "  Warn: \$display_name doesn't contain commit \$sha1_dst")"
 890                         ;;
 891                 t,t)
 892                         errmsg="$(eval_gettext "  Warn: \$display_name doesn't contain commits \$sha1_src and \$sha1_dst")"
 893                         ;;
 894                 *)
 895                         errmsg=
 896                         total_commits=$(
 897                         if test $mod_src = 160000 && test $mod_dst = 160000
 898                         then
 899                                 range="$sha1_src...$sha1_dst"
 900                         elif test $mod_src = 160000
 901                         then
 902                                 range=$sha1_src
 903                         else
 904                                 range=$sha1_dst
 905                         fi
 906                         GIT_DIR="$name/.git" \
 907                         git rev-list --first-parent $range -- | wc -l
 908                         )
 909                         total_commits=" ($(($total_commits + 0)))"
 910                         ;;
 911                 esac
 912
 913                 sha1_abbr_src=$(echo $sha1_src | cut -c1-7)
 914                 sha1_abbr_dst=$(echo $sha1_dst | cut -c1-7)
 915                 if test $status = T
 916                 then
 917                         blob="$(gettext "blob")"
 918                         submodule="$(gettext "submodule")"
 919                         if test $mod_dst = 160000
 920                         then
 921                                 echo "* $display_name $sha1_abbr_src($blob)->$sha1_abbr_dst($submodule)$total_commits:"
 922                         else
 923                                 echo "* $display_name $sha1_abbr_src($submodule)->$sha1_abbr_dst($blob)$total_commits:"
 924                         fi
 925                 else
 926                         echo "* $display_name $sha1_abbr_src...$sha1_abbr_dst$total_commits:"
 927                 fi
 928                 if test -n "$errmsg"
 929                 then
 930                         # Don't give error msg for modification whose dst is not submodule
 931                         # i.e. deleted or changed to blob
 932                         test $mod_dst = 160000 && echo "$errmsg"
 933                 else
 934                         if test $mod_src = 160000 && test $mod_dst = 160000
 935                         then
 936                                 limit=
 937                                 test $summary_limit -gt 0 && limit="-$summary_limit"
 938                                 GIT_DIR="$name/.git" \
 939                                 git log $limit --pretty='format:  %m %s' \
 940                                 --first-parent $sha1_src...$sha1_dst
 941                         elif test $mod_dst = 160000
 942                         then
 943                                 GIT_DIR="$name/.git" \
 944                                 git log --pretty='format:  > %s' -1 $sha1_dst
 945                         else
 946                                 GIT_DIR="$name/.git" \
 947                                 git log --pretty='format:  < %s' -1 $sha1_src
 948                         fi
 949                         echo
 950                 fi
 951                 echo
 952         done
 953 }
 954 #
 955 # List all submodules, prefixed with:
 956 #  - submodule not initialized
 957 #  + different revision checked out
 958 #
 959 # If --cached was specified the revision in the index will be printed
 960 # instead of the currently checked out revision.
 961 #
 962 # $@ = requested paths (default to all)
 963 #
 964 cmd_status()
 965 {
 966         # parse $args after "submodule ... status".
 967         while test $# -ne 0
 968         do
 969                 case "$1" in
 970                 -q|--quiet)
 971                         GIT_QUIET=1
 972                         ;;
 973                 --cached)
 974                         cached=1
 975                         ;;
 976                 --recursive)
 977                         recursive=1
 978                         ;;
 979                 --)
 980                         shift
 981                         break
 982                         ;;
 983                 -*)
 984                         usage
 985                         ;;
 986                 *)
 987                         break
 988                         ;;
 989                 esac
 990                 shift
 991         done
 992
 993         {
 994                 git submodule--helper list --prefix "$wt_prefix" "$@" ||
 995                 echo "#unmatched" $?
 996         } |
 997         while read mode sha1 stage sm_path
 998         do
 999                 die_if_unmatched "$mode" "$sha1"
1000                 name=$(git submodule--helper name "$sm_path") || exit
1001                 url=$(git config submodule."$name".url)
1002                 displaypath=$(git submodule--helper relative-path "$prefix$sm_path" "$wt_prefix")
1003                 if test "$stage" = U
1004                 then
1005                         say "U$sha1 $displaypath"
1006                         continue
1007                 fi
1008                 if test -z "$url" ||
1009                 {
1010                         ! test -d "$sm_path"/.git &&
1011                         ! test -f "$sm_path"/.git
1012                 }
1013                 then
1014                         say "-$sha1 $displaypath"
1015                         continue;
1016                 fi
1017                 if git diff-files --ignore-submodules=dirty --quiet -- "$sm_path"
1018                 then
1019                         set_name_rev "$sm_path" "$sha1"
1020                         say " $sha1 $displaypath$revname"
1021                 else
1022                         if test -z "$cached"
1023                         then
1024                                 sha1=$(sanitize_submodule_env; cd "$sm_path" && git rev-parse --verify HEAD)
1025                         fi
1026                         set_name_rev "$sm_path" "$sha1"
1027                         say "+$sha1 $displaypath$revname"
1028                 fi
1029
1030                 if test -n "$recursive"
1031                 then
1032                         (
1033                                 prefix="$displaypath/"
1034                                 sanitize_submodule_env
1035                                 wt_prefix=
1036                                 cd "$sm_path" &&
1037                                 eval cmd_status
1038                         ) ||
1039                         die "$(eval_gettext "Failed to recurse into submodule path '\$sm_path'")"
1040                 fi
1041         done
1042 }
1043 #
1044 # Sync remote urls for submodules
1045 # This makes the value for remote.$remote.url match the value
1046 # specified in .gitmodules.
1047 #
1048 cmd_sync()
1049 {
1050         while test $# -ne 0
1051         do
1052                 case "$1" in
1053                 -q|--quiet)
1054                         GIT_QUIET=1
1055                         shift
1056                         ;;
1057                 --recursive)
1058                         recursive=1
1059                         shift
1060                         ;;
1061                 --)
1062                         shift
1063                         break
1064                         ;;
1065                 -*)
1066                         usage
1067                         ;;
1068                 *)
1069                         break
1070                         ;;
1071                 esac
1072         done
1073         cd_to_toplevel
1074         {
1075                 git submodule--helper list --prefix "$wt_prefix" "$@" ||
1076                 echo "#unmatched" $?
1077         } |
1078         while read mode sha1 stage sm_path
1079         do
1080                 die_if_unmatched "$mode" "$sha1"
1081                 name=$(git submodule--helper name "$sm_path")
1082                 url=$(git config -f .gitmodules --get submodule."$name".url)
1083
1084                 # Possibly a url relative to parent
1085                 case "$url" in
1086                 ./*|../*)
1087                         # rewrite foo/bar as ../.. to find path from
1088                         # submodule work tree to superproject work tree
1089                         up_path="$(printf '%s\n' "$sm_path" | sed "s/[^/][^/]*/../g")" &&
1090                         # guarantee a trailing /
1091                         up_path=${up_path%/}/ &&
1092                         # path from submodule work tree to submodule origin repo
1093                         sub_origin_url=$(git submodule--helper resolve-relative-url "$url" "$up_path") &&
1094                         # path from superproject work tree to submodule origin repo
1095                         super_config_url=$(git submodule--helper resolve-relative-url "$url") || exit
1096                         ;;
1097                 *)
1098                         sub_origin_url="$url"
1099                         super_config_url="$url"
1100                         ;;
1101                 esac
1102
1103                 if git config "submodule.$name.url" >/dev/null 2>/dev/null
1104                 then
1105                         displaypath=$(git submodule--helper relative-path "$prefix$sm_path" "$wt_prefix")
1106                         say "$(eval_gettext "Synchronizing submodule url for '\$displaypath'")"
1107                         git config submodule."$name".url "$super_config_url"
1108
1109                         if test -e "$sm_path"/.git
1110                         then
1111                         (
1112                                 sanitize_submodule_env
1113                                 cd "$sm_path"
1114                                 remote=$(get_default_remote)
1115                                 git config remote."$remote".url "$sub_origin_url"
1116
1117                                 if test -n "$recursive"
1118                                 then
1119                                         prefix="$prefix$sm_path/"
1120                                         eval cmd_sync
1121                                 fi
1122                         )
1123                         fi
1124                 fi
1125         done
1126 }
1127
1128 # This loop parses the command line arguments to find the
1129 # subcommand name to dispatch.  Parsing of the subcommand specific
1130 # options are primarily done by the subcommand implementations.
1131 # Subcommand specific options such as --branch and --cached are
1132 # parsed here as well, for backward compatibility.
1133
1134 while test $# != 0 && test -z "$command"
1135 do
1136         case "$1" in
1137         add | foreach | init | deinit | update | status | summary | sync)
1138                 command=$1
1139                 ;;
1140         -q|--quiet)
1141                 GIT_QUIET=1
1142                 ;;
1143         -b|--branch)
1144                 case "$2" in
1145                 '')
1146                         usage
1147                         ;;
1148                 esac
1149                 branch="$2"; shift
1150                 ;;
1151         --cached)
1152                 cached="$1"
1153                 ;;
1154         --)
1155                 break
1156                 ;;
1157         -*)
1158                 usage
1159                 ;;
1160         *)
1161                 break
1162                 ;;
1163         esac
1164         shift
1165 done
1166
1167 # No command word defaults to "status"
1168 if test -z "$command"
1169 then
1170     if test $# = 0
1171     then
1172         command=status
1173     else
1174         usage
1175     fi
1176 fi
1177
1178 # "-b branch" is accepted only by "add"
1179 if test -n "$branch" && test "$command" != add
1180 then
1181         usage
1182 fi
1183
1184 # "--cached" is accepted only by "status" and "summary"
1185 if test -n "$cached" && test "$command" != status && test "$command" != summary
1186 then
1187         usage
1188 fi
1189
1190 "cmd_$command" "$@"