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