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