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