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