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