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