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] [--cached]
   9    or: $dashless [--quiet] add [-b <branch>] [-f|--force] [--name <name>] [--reference <repository>] [--] <repository> [<path>]
  10    or: $dashless [--quiet] status [--cached] [--recursive] [--] [<path>...]
  11    or: $dashless [--quiet] init [--] [<path>...]
  12    or: $dashless [--quiet] deinit [-f|--force] (--all| [--] <path>...)
  13    or: $dashless [--quiet] update [--init] [--remote] [-N|--no-fetch] [-f|--force] [--checkout|--merge|--rebase] [--[no-]recommend-shallow] [--reference <repository>] [--recursive] [--[no-]single-branch] [--] [<path>...]
  14    or: $dashless [--quiet] set-branch (--default|--branch <branch>) [--] <path>
  15    or: $dashless [--quiet] set-url [--] <path> <newurl>
  16    or: $dashless [--quiet] summary [--cached|--files] [--summary-limit <n>] [commit] [--] [<path>...]
  17    or: $dashless [--quiet] foreach [--recursive] <command>
  18    or: $dashless [--quiet] sync [--recursive] [--] [<path>...]
  19    or: $dashless [--quiet] absorbgitdirs [--] [<path>...]"
  20 OPTIONS_SPEC=
  21 SUBDIRECTORY_OK=Yes
  22 . git-sh-setup
  23 require_work_tree
  24 wt_prefix=$(git rev-parse --show-prefix)
  25 cd_to_toplevel
  26
  27 # Tell the rest of git that any URLs we get don't come
  28 # directly from the user, so it can apply policy as appropriate.
  29 GIT_PROTOCOL_FROM_USER=0
  30 export GIT_PROTOCOL_FROM_USER
  31
  32 command=
  33 branch=
  34 force=
  35 reference=
  36 cached=
  37 recursive=
  38 init=
  39 require_init=
  40 files=
  41 remote=
  42 nofetch=
  43 update=
  44 prefix=
  45 custom_name=
  46 depth=
  47 progress=
  48 dissociate=
  49 single_branch=
  50 jobs=
  51 recommend_shallow=
  52
  53 die_if_unmatched ()
  54 {
  55         if test "$1" = "#unmatched"
  56         then
  57                 exit ${2:-1}
  58         fi
  59 }
  60
  61 isnumber()
  62 {
  63         n=$(($1 + 0)) 2>/dev/null && test "$n" = "$1"
  64 }
  65
  66 # Given a full hex object ID, is this the zero OID?
  67 is_zero_oid () {
  68         echo "$1" | sane_egrep '^0+$' >/dev/null 2>&1
  69 }
  70
  71 # Sanitize the local git environment for use within a submodule. We
  72 # can't simply use clear_local_git_env since we want to preserve some
  73 # of the settings from GIT_CONFIG_PARAMETERS.
  74 sanitize_submodule_env()
  75 {
  76         save_config=$GIT_CONFIG_PARAMETERS
  77         clear_local_git_env
  78         GIT_CONFIG_PARAMETERS=$save_config
  79         export GIT_CONFIG_PARAMETERS
  80 }
  81
  82 #
  83 # Add a new submodule to the working tree, .gitmodules and the index
  84 #
  85 # $@ = repo path
  86 #
  87 # optional branch is stored in global branch variable
  88 #
  89 cmd_add()
  90 {
  91         # parse $args after "submodule ... add".
  92         reference_path=
  93         while test $# -ne 0
  94         do
  95                 case "$1" in
  96                 -b | --branch)
  97                         case "$2" in '') usage ;; esac
  98                         branch=$2
  99                         shift
 100                         ;;
 101                 -f | --force)
 102                         force=$1
 103                         ;;
 104                 -q|--quiet)
 105                         GIT_QUIET=1
 106                         ;;
 107                 --progress)
 108                         progress=1
 109                         ;;
 110                 --reference)
 111                         case "$2" in '') usage ;; esac
 112                         reference_path=$2
 113                         shift
 114                         ;;
 115                 --reference=*)
 116                         reference_path="${1#--reference=}"
 117                         ;;
 118                 --dissociate)
 119                         dissociate=1
 120                         ;;
 121                 --name)
 122                         case "$2" in '') usage ;; esac
 123                         custom_name=$2
 124                         shift
 125                         ;;
 126                 --depth)
 127                         case "$2" in '') usage ;; esac
 128                         depth="--depth=$2"
 129                         shift
 130                         ;;
 131                 --depth=*)
 132                         depth=$1
 133                         ;;
 134                 --)
 135                         shift
 136                         break
 137                         ;;
 138                 -*)
 139                         usage
 140                         ;;
 141                 *)
 142                         break
 143                         ;;
 144                 esac
 145                 shift
 146         done
 147
 148         if test -z "$1"
 149         then
 150                 usage
 151         fi
 152
 153         git ${wt_prefix:+-C "$wt_prefix"} ${prefix:+--super-prefix "$prefix"} submodule--helper add ${GIT_QUIET:+--quiet} ${force:+--force} ${progress:+"--progress"} ${branch:+--branch "$branch"} ${reference_path:+--reference "$reference_path"} ${dissociate:+--dissociate} ${custom_name:+--name "$custom_name"} ${depth:+"$depth"} -- "$@"
 154 }
 155
 156 #
 157 # Execute an arbitrary command sequence in each checked out
 158 # submodule
 159 #
 160 # $@ = command to execute
 161 #
 162 cmd_foreach()
 163 {
 164         # parse $args after "submodule ... foreach".
 165         while test $# -ne 0
 166         do
 167                 case "$1" in
 168                 -q|--quiet)
 169                         GIT_QUIET=1
 170                         ;;
 171                 --recursive)
 172                         recursive=1
 173                         ;;
 174                 -*)
 175                         usage
 176                         ;;
 177                 *)
 178                         break
 179                         ;;
 180                 esac
 181                 shift
 182         done
 183
 184         git ${wt_prefix:+-C "$wt_prefix"} submodule--helper foreach ${GIT_QUIET:+--quiet} ${recursive:+--recursive} -- "$@"
 185 }
 186
 187 #
 188 # Register submodules in .git/config
 189 #
 190 # $@ = requested paths (default to all)
 191 #
 192 cmd_init()
 193 {
 194         # parse $args after "submodule ... init".
 195         while test $# -ne 0
 196         do
 197                 case "$1" in
 198                 -q|--quiet)
 199                         GIT_QUIET=1
 200                         ;;
 201                 --)
 202                         shift
 203                         break
 204                         ;;
 205                 -*)
 206                         usage
 207                         ;;
 208                 *)
 209                         break
 210                         ;;
 211                 esac
 212                 shift
 213         done
 214
 215         git ${wt_prefix:+-C "$wt_prefix"} ${prefix:+--super-prefix "$prefix"} submodule--helper init ${GIT_QUIET:+--quiet} -- "$@"
 216 }
 217
 218 #
 219 # Unregister submodules from .git/config and remove their work tree
 220 #
 221 cmd_deinit()
 222 {
 223         # parse $args after "submodule ... deinit".
 224         deinit_all=
 225         while test $# -ne 0
 226         do
 227                 case "$1" in
 228                 -f|--force)
 229                         force=$1
 230                         ;;
 231                 -q|--quiet)
 232                         GIT_QUIET=1
 233                         ;;
 234                 --all)
 235                         deinit_all=t
 236                         ;;
 237                 --)
 238                         shift
 239                         break
 240                         ;;
 241                 -*)
 242                         usage
 243                         ;;
 244                 *)
 245                         break
 246                         ;;
 247                 esac
 248                 shift
 249         done
 250
 251         git ${wt_prefix:+-C "$wt_prefix"} submodule--helper deinit ${GIT_QUIET:+--quiet} ${force:+--force} ${deinit_all:+--all} -- "$@"
 252 }
 253
 254 # usage: fetch_in_submodule <module_path> [<depth>] [<sha1>]
 255 # Because arguments are positional, use an empty string to omit <depth>
 256 # but include <sha1>.
 257 fetch_in_submodule () (
 258         sanitize_submodule_env &&
 259         cd "$1" &&
 260         if test $# -eq 3
 261         then
 262                 echo "$3" | git fetch ${GIT_QUIET:+--quiet} --stdin ${2:+"$2"}
 263         else
 264                 git fetch ${GIT_QUIET:+--quiet} ${2:+"$2"}
 265         fi
 266 )
 267
 268 #
 269 # Update each submodule path to correct revision, using clone and checkout as needed
 270 #
 271 # $@ = requested paths (default to all)
 272 #
 273 cmd_update()
 274 {
 275         # parse $args after "submodule ... update".
 276         while test $# -ne 0
 277         do
 278                 case "$1" in
 279                 -q|--quiet)
 280                         GIT_QUIET=1
 281                         ;;
 282                 -v)
 283                         unset GIT_QUIET
 284                         ;;
 285                 --progress)
 286                         progress=1
 287                         ;;
 288                 -i|--init)
 289                         init=1
 290                         ;;
 291                 --require-init)
 292                         init=1
 293                         require_init=1
 294                         ;;
 295                 --remote)
 296                         remote=1
 297                         ;;
 298                 -N|--no-fetch)
 299                         nofetch=1
 300                         ;;
 301                 -f|--force)
 302                         force=$1
 303                         ;;
 304                 -r|--rebase)
 305                         update="rebase"
 306                         ;;
 307                 --reference)
 308                         case "$2" in '') usage ;; esac
 309                         reference="--reference=$2"
 310                         shift
 311                         ;;
 312                 --reference=*)
 313                         reference="$1"
 314                         ;;
 315                 --dissociate)
 316                         dissociate=1
 317                         ;;
 318                 -m|--merge)
 319                         update="merge"
 320                         ;;
 321                 --recursive)
 322                         recursive=1
 323                         ;;
 324                 --checkout)
 325                         update="checkout"
 326                         ;;
 327                 --recommend-shallow)
 328                         recommend_shallow="--recommend-shallow"
 329                         ;;
 330                 --no-recommend-shallow)
 331                         recommend_shallow="--no-recommend-shallow"
 332                         ;;
 333                 --depth)
 334                         case "$2" in '') usage ;; esac
 335                         depth="--depth=$2"
 336                         shift
 337                         ;;
 338                 --depth=*)
 339                         depth=$1
 340                         ;;
 341                 -j|--jobs)
 342                         case "$2" in '') usage ;; esac
 343                         jobs="--jobs=$2"
 344                         shift
 345                         ;;
 346                 --jobs=*)
 347                         jobs=$1
 348                         ;;
 349                 --single-branch)
 350                         single_branch="--single-branch"
 351                         ;;
 352                 --no-single-branch)
 353                         single_branch="--no-single-branch"
 354                         ;;
 355                 --)
 356                         shift
 357                         break
 358                         ;;
 359                 -*)
 360                         usage
 361                         ;;
 362                 *)
 363                         break
 364                         ;;
 365                 esac
 366                 shift
 367         done
 368
 369         if test -n "$init"
 370         then
 371                 cmd_init "--" "$@" || return
 372         fi
 373
 374         {
 375         git submodule--helper update-clone ${GIT_QUIET:+--quiet} \
 376                 ${progress:+"--progress"} \
 377                 ${wt_prefix:+--prefix "$wt_prefix"} \
 378                 ${prefix:+--recursive-prefix "$prefix"} \
 379                 ${update:+--update "$update"} \
 380                 ${reference:+"$reference"} \
 381                 ${dissociate:+"--dissociate"} \
 382                 ${depth:+--depth "$depth"} \
 383                 ${require_init:+--require-init} \
 384                 $single_branch \
 385                 $recommend_shallow \
 386                 $jobs \
 387                 -- \
 388                 "$@" || echo "#unmatched" $?
 389         } | {
 390         err=
 391         while read -r quickabort sha1 just_cloned sm_path
 392         do
 393                 die_if_unmatched "$quickabort" "$sha1"
 394
 395                 git submodule--helper ensure-core-worktree "$sm_path" || exit 1
 396
 397                 displaypath=$(git submodule--helper relative-path "$prefix$sm_path" "$wt_prefix")
 398
 399                 if test $just_cloned -eq 1
 400                 then
 401                         subsha1=
 402                 else
 403                         just_cloned=
 404                         subsha1=$(sanitize_submodule_env; cd "$sm_path" &&
 405                                 git rev-parse --verify HEAD) ||
 406                         die "fatal: $(eval_gettext "Unable to find current revision in submodule path '\$displaypath'")"
 407                 fi
 408
 409                 if test -n "$remote"
 410                 then
 411                         branch=$(git submodule--helper remote-branch "$sm_path")
 412                         if test -z "$nofetch"
 413                         then
 414                                 # Fetch remote before determining tracking $sha1
 415                                 fetch_in_submodule "$sm_path" $depth ||
 416                                 die "fatal: $(eval_gettext "Unable to fetch in submodule path '\$sm_path'")"
 417                         fi
 418                         remote_name=$(sanitize_submodule_env; cd "$sm_path" && git submodule--helper print-default-remote)
 419                         sha1=$(sanitize_submodule_env; cd "$sm_path" &&
 420                                 git rev-parse --verify "${remote_name}/${branch}") ||
 421                         die "fatal: $(eval_gettext "Unable to find current \${remote_name}/\${branch} revision in submodule path '\$sm_path'")"
 422                 fi
 423
 424                 out=$(git submodule--helper run-update-procedure \
 425                           ${wt_prefix:+--prefix "$wt_prefix"} \
 426                           ${GIT_QUIET:+--quiet} \
 427                           ${force:+--force} \
 428                           ${just_cloned:+--just-cloned} \
 429                           ${nofetch:+--no-fetch} \
 430                           ${depth:+"$depth"} \
 431                           ${update:+--update "$update"} \
 432                           ${prefix:+--recursive-prefix "$prefix"} \
 433                           ${sha1:+--oid "$sha1"} \
 434                           ${subsha1:+--suboid "$subsha1"} \
 435                           "--" \
 436                           "$sm_path")
 437
 438                 # exit codes for run-update-procedure:
 439                 # 0: update was successful, say command output
 440                 # 1: update procedure failed, but should not die
 441                 # 2 or 128: subcommand died during execution
 442                 # 3: no update procedure was run
 443                 res="$?"
 444                 case $res in
 445                 0)
 446                         say "$out"
 447                         ;;
 448                 1)
 449                         err="${err};fatal: $out"
 450                         continue
 451                         ;;
 452                 2|128)
 453                         die_with_status $res "fatal: $out"
 454                         ;;
 455                 esac
 456
 457                 if test -n "$recursive"
 458                 then
 459                         (
 460                                 prefix=$(git submodule--helper relative-path "$prefix$sm_path/" "$wt_prefix")
 461                                 wt_prefix=
 462                                 sanitize_submodule_env
 463                                 cd "$sm_path" &&
 464                                 eval cmd_update
 465                         )
 466                         res=$?
 467                         if test $res -gt 0
 468                         then
 469                                 die_msg="fatal: $(eval_gettext "Failed to recurse into submodule path '\$displaypath'")"
 470                                 if test $res -ne 2
 471                                 then
 472                                         err="${err};$die_msg"
 473                                         continue
 474                                 else
 475                                         die_with_status $res "$die_msg"
 476                                 fi
 477                         fi
 478                 fi
 479         done
 480
 481         if test -n "$err"
 482         then
 483                 OIFS=$IFS
 484                 IFS=';'
 485                 for e in $err
 486                 do
 487                         if test -n "$e"
 488                         then
 489                                 echo >&2 "$e"
 490                         fi
 491                 done
 492                 IFS=$OIFS
 493                 exit 1
 494         fi
 495         }
 496 }
 497
 498 #
 499 # Configures a submodule's default branch
 500 #
 501 # $@ = requested path
 502 #
 503 cmd_set_branch() {
 504         default=
 505         branch=
 506
 507         while test $# -ne 0
 508         do
 509                 case "$1" in
 510                 -q|--quiet)
 511                         # we don't do anything with this but we need to accept it
 512                         ;;
 513                 -d|--default)
 514                         default=1
 515                         ;;
 516                 -b|--branch)
 517                         case "$2" in '') usage ;; esac
 518                         branch=$2
 519                         shift
 520                         ;;
 521                 --)
 522                         shift
 523                         break
 524                         ;;
 525                 -*)
 526                         usage
 527                         ;;
 528                 *)
 529                         break
 530                         ;;
 531                 esac
 532                 shift
 533         done
 534
 535         git ${wt_prefix:+-C "$wt_prefix"} submodule--helper set-branch ${GIT_QUIET:+--quiet} ${branch:+--branch "$branch"} ${default:+--default} -- "$@"
 536 }
 537
 538 #
 539 # Configures a submodule's remote url
 540 #
 541 # $@ = requested path, requested url
 542 #
 543 cmd_set_url() {
 544         while test $# -ne 0
 545         do
 546                 case "$1" in
 547                 -q|--quiet)
 548                         GIT_QUIET=1
 549                         ;;
 550                 --)
 551                         shift
 552                         break
 553                         ;;
 554                 -*)
 555                         usage
 556                         ;;
 557                 *)
 558                         break
 559                         ;;
 560                 esac
 561                 shift
 562         done
 563
 564         git ${wt_prefix:+-C "$wt_prefix"} submodule--helper set-url ${GIT_QUIET:+--quiet} -- "$@"
 565 }
 566
 567 #
 568 # Show commit summary for submodules in index or working tree
 569 #
 570 # If '--cached' is given, show summary between index and given commit,
 571 # or between working tree and given commit
 572 #
 573 # $@ = [commit (default 'HEAD'),] requested paths (default all)
 574 #
 575 cmd_summary() {
 576         summary_limit=-1
 577         for_status=
 578         diff_cmd=diff-index
 579
 580         # parse $args after "submodule ... summary".
 581         while test $# -ne 0
 582         do
 583                 case "$1" in
 584                 --cached)
 585                         cached="$1"
 586                         ;;
 587                 --files)
 588                         files="$1"
 589                         ;;
 590                 --for-status)
 591                         for_status="$1"
 592                         ;;
 593                 -n|--summary-limit)
 594                         summary_limit="$2"
 595                         isnumber "$summary_limit" || usage
 596                         shift
 597                         ;;
 598                 --summary-limit=*)
 599                         summary_limit="${1#--summary-limit=}"
 600                         isnumber "$summary_limit" || usage
 601                         ;;
 602                 --)
 603                         shift
 604                         break
 605                         ;;
 606                 -*)
 607                         usage
 608                         ;;
 609                 *)
 610                         break
 611                         ;;
 612                 esac
 613                 shift
 614         done
 615
 616         git ${wt_prefix:+-C "$wt_prefix"} submodule--helper summary ${files:+--files} ${cached:+--cached} ${for_status:+--for-status} ${summary_limit:+-n $summary_limit} -- "$@"
 617 }
 618 #
 619 # List all submodules, prefixed with:
 620 #  - submodule not initialized
 621 #  + different revision checked out
 622 #
 623 # If --cached was specified the revision in the index will be printed
 624 # instead of the currently checked out revision.
 625 #
 626 # $@ = requested paths (default to all)
 627 #
 628 cmd_status()
 629 {
 630         # parse $args after "submodule ... status".
 631         while test $# -ne 0
 632         do
 633                 case "$1" in
 634                 -q|--quiet)
 635                         GIT_QUIET=1
 636                         ;;
 637                 --cached)
 638                         cached=1
 639                         ;;
 640                 --recursive)
 641                         recursive=1
 642                         ;;
 643                 --)
 644                         shift
 645                         break
 646                         ;;
 647                 -*)
 648                         usage
 649                         ;;
 650                 *)
 651                         break
 652                         ;;
 653                 esac
 654                 shift
 655         done
 656
 657         git ${wt_prefix:+-C "$wt_prefix"} submodule--helper status ${GIT_QUIET:+--quiet} ${cached:+--cached} ${recursive:+--recursive} -- "$@"
 658 }
 659 #
 660 # Sync remote urls for submodules
 661 # This makes the value for remote.$remote.url match the value
 662 # specified in .gitmodules.
 663 #
 664 cmd_sync()
 665 {
 666         while test $# -ne 0
 667         do
 668                 case "$1" in
 669                 -q|--quiet)
 670                         GIT_QUIET=1
 671                         shift
 672                         ;;
 673                 --recursive)
 674                         recursive=1
 675                         shift
 676                         ;;
 677                 --)
 678                         shift
 679                         break
 680                         ;;
 681                 -*)
 682                         usage
 683                         ;;
 684                 *)
 685                         break
 686                         ;;
 687                 esac
 688         done
 689
 690         git ${wt_prefix:+-C "$wt_prefix"} submodule--helper sync ${GIT_QUIET:+--quiet} ${recursive:+--recursive} -- "$@"
 691 }
 692
 693 cmd_absorbgitdirs()
 694 {
 695         git submodule--helper absorb-git-dirs --prefix "$wt_prefix" "$@"
 696 }
 697
 698 # This loop parses the command line arguments to find the
 699 # subcommand name to dispatch.  Parsing of the subcommand specific
 700 # options are primarily done by the subcommand implementations.
 701 # Subcommand specific options such as --branch and --cached are
 702 # parsed here as well, for backward compatibility.
 703
 704 while test $# != 0 && test -z "$command"
 705 do
 706         case "$1" in
 707         add | foreach | init | deinit | update | set-branch | set-url | status | summary | sync | absorbgitdirs)
 708                 command=$1
 709                 ;;
 710         -q|--quiet)
 711                 GIT_QUIET=1
 712                 ;;
 713         -b|--branch)
 714                 case "$2" in
 715                 '')
 716                         usage
 717                         ;;
 718                 esac
 719                 branch="$2"; shift
 720                 ;;
 721         --cached)
 722                 cached="$1"
 723                 ;;
 724         --)
 725                 break
 726                 ;;
 727         -*)
 728                 usage
 729                 ;;
 730         *)
 731                 break
 732                 ;;
 733         esac
 734         shift
 735 done
 736
 737 # No command word defaults to "status"
 738 if test -z "$command"
 739 then
 740     if test $# = 0
 741     then
 742         command=status
 743     else
 744         usage
 745     fi
 746 fi
 747
 748 # "-b branch" is accepted only by "add" and "set-branch"
 749 if test -n "$branch" && (test "$command" != add || test "$command" != set-branch)
 750 then
 751         usage
 752 fi
 753
 754 # "--cached" is accepted only by "status" and "summary"
 755 if test -n "$cached" && test "$command" != status && test "$command" != summary
 756 then
 757         usage
 758 fi
 759
 760 "cmd_$(echo $command | sed -e s/-/_/g)" "$@"