git-submodule.sh

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