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] [--] <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 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 --)
428 shift
429 break
430 ;;
431 -*)
432 usage
433 ;;
434 *)
435 break
436 ;;
437 esac
438 shift
439 done
440 if test $# = 0
442 then
443 die "$(eval_gettext "Use '.' if you really want to deinitialize all submodules")"
444 fi
445 git submodule--helper list --prefix "$wt_prefix" "$@" |
447 while read mode sha1 stage sm_path
448 do
449 die_if_unmatched "$mode"
450 name=$(git submodule--helper name "$sm_path") || exit
451 displaypath=$(relative_path "$sm_path")
453 # Remove the submodule work tree (unless the user already did it)
455 if test -d "$sm_path"
456 then
457 # Protect submodules containing a .git directory
458 if test -d "$sm_path/.git"
459 then
460 echo >&2 "$(eval_gettext "Submodule work tree '\$displaypath' contains a .git directory")"
461 die "$(eval_gettext "(use 'rm -rf' if you really want to remove it including all of its history)")"
462 fi
463 if test -z "$force"
465 then
466 git rm -qn "$sm_path" ||
467 die "$(eval_gettext "Submodule work tree '\$displaypath' contains local modifications; use '-f' to discard them")"
468 fi
469 rm -rf "$sm_path" &&
470 say "$(eval_gettext "Cleared directory '\$displaypath'")" ||
471 say "$(eval_gettext "Could not remove submodule work tree '\$displaypath'")"
472 fi
473 mkdir "$sm_path" || say "$(eval_gettext "Could not create empty submodule directory '\$displaypath'")"
475 # Remove the .git/config entries (unless the user already did it)
477 if test -n "$(git config --get-regexp submodule."$name\.")"
478 then
479 # Remove the whole section so we have a clean state when
480 # the user later decides to init this submodule again
481 url=$(git config submodule."$name".url)
482 git config --remove-section submodule."$name" 2>/dev/null &&
483 say "$(eval_gettext "Submodule '\$name' (\$url) unregistered for path '\$displaypath'")"
484 fi
485 done
486}
487is_tip_reachable () (
489 sanitize_submodule_env &&
490 cd "$1" &&
491 rev=$(git rev-list -n 1 "$2" --not --all 2>/dev/null) &&
492 test -z "$rev"
493)
494fetch_in_submodule () (
496 sanitize_submodule_env &&
497 cd "$1" &&
498 case "$2" in
499 '')
500 git fetch ;;
501 *)
502 git fetch $(get_default_remote) "$2" ;;
503 esac
504)
505#
507# Update each submodule path to correct revision, using clone and checkout as needed
508#
509# $@ = requested paths (default to all)
510#
511cmd_update()
512{
513 # parse $args after "submodule ... update".
514 while test $# -ne 0
515 do
516 case "$1" in
517 -q|--quiet)
518 GIT_QUIET=1
519 ;;
520 -i|--init)
521 init=1
522 ;;
523 --remote)
524 remote=1
525 ;;
526 -N|--no-fetch)
527 nofetch=1
528 ;;
529 -f|--force)
530 force=$1
531 ;;
532 -r|--rebase)
533 update="rebase"
534 ;;
535 --reference)
536 case "$2" in '') usage ;; esac
537 reference="--reference=$2"
538 shift
539 ;;
540 --reference=*)
541 reference="$1"
542 ;;
543 -m|--merge)
544 update="merge"
545 ;;
546 --recursive)
547 recursive=1
548 ;;
549 --checkout)
550 update="checkout"
551 ;;
552 --depth)
553 case "$2" in '') usage ;; esac
554 depth="--depth=$2"
555 shift
556 ;;
557 --depth=*)
558 depth=$1
559 ;;
560 -j|--jobs)
561 case "$2" in '') usage ;; esac
562 jobs="--jobs=$2"
563 shift
564 ;;
565 --jobs=*)
566 jobs=$1
567 ;;
568 --)
569 shift
570 break
571 ;;
572 -*)
573 usage
574 ;;
575 *)
576 break
577 ;;
578 esac
579 shift
580 done
581 if test -n "$init"
583 then
584 cmd_init "--" "$@" || return
585 fi
586 {
588 git submodule--helper update-clone ${GIT_QUIET:+--quiet} \
589 ${wt_prefix:+--prefix "$wt_prefix"} \
590 ${prefix:+--recursive-prefix "$prefix"} \
591 ${update:+--update "$update"} \
592 ${reference:+--reference "$reference"} \
593 ${depth:+--depth "$depth"} \
594 ${jobs:+$jobs} \
595 "$@" || echo "#unmatched"
596 } | {
597 err=
598 while read mode sha1 stage just_cloned sm_path
599 do
600 die_if_unmatched "$mode"
601 name=$(git submodule--helper name "$sm_path") || exit
603 url=$(git config submodule."$name".url)
604 branch=$(get_submodule_config "$name" branch master)
605 if ! test -z "$update"
606 then
607 update_module=$update
608 else
609 update_module=$(git config submodule."$name".update)
610 if test -z "$update_module"
611 then
612 update_module="checkout"
613 fi
614 fi
615 displaypath=$(relative_path "$prefix$sm_path")
617 if test $just_cloned -eq 1
619 then
620 subsha1=
621 update_module=checkout
622 else
623 subsha1=$(sanitize_submodule_env; cd "$sm_path" &&
624 git rev-parse --verify HEAD) ||
625 die "$(eval_gettext "Unable to find current revision in submodule path '\$displaypath'")"
626 fi
627 if test -n "$remote"
629 then
630 if test -z "$nofetch"
631 then
632 # Fetch remote before determining tracking $sha1
633 (sanitize_submodule_env; cd "$sm_path" && git-fetch) ||
634 die "$(eval_gettext "Unable to fetch in submodule path '\$sm_path'")"
635 fi
636 remote_name=$(sanitize_submodule_env; cd "$sm_path" && get_default_remote)
637 sha1=$(sanitize_submodule_env; cd "$sm_path" &&
638 git rev-parse --verify "${remote_name}/${branch}") ||
639 die "$(eval_gettext "Unable to find current ${remote_name}/${branch} revision in submodule path '\$sm_path'")"
640 fi
641 if test "$subsha1" != "$sha1" || test -n "$force"
643 then
644 subforce=$force
645 # If we don't already have a -f flag and the submodule has never been checked out
646 if test -z "$subsha1" && test -z "$force"
647 then
648 subforce="-f"
649 fi
650 if test -z "$nofetch"
652 then
653 # Run fetch only if $sha1 isn't present or it
654 # is not reachable from a ref.
655 is_tip_reachable "$sm_path" "$sha1" ||
656 fetch_in_submodule "$sm_path" ||
657 die "$(eval_gettext "Unable to fetch in submodule path '\$displaypath'")"
658 # Now we tried the usual fetch, but $sha1 may
660 # not be reachable from any of the refs
661 is_tip_reachable "$sm_path" "$sha1" ||
662 fetch_in_submodule "$sm_path" "$sha1" ||
663 die "$(eval_gettext "Fetched in submodule path '\$displaypath', but it did not contain $sha1. Direct fetching of that commit failed.")"
664 fi
665 must_die_on_failure=
667 case "$update_module" in
668 checkout)
669 command="git checkout $subforce -q"
670 die_msg="$(eval_gettext "Unable to checkout '\$sha1' in submodule path '\$displaypath'")"
671 say_msg="$(eval_gettext "Submodule path '\$displaypath': checked out '\$sha1'")"
672 ;;
673 rebase)
674 command="git rebase"
675 die_msg="$(eval_gettext "Unable to rebase '\$sha1' in submodule path '\$displaypath'")"
676 say_msg="$(eval_gettext "Submodule path '\$displaypath': rebased into '\$sha1'")"
677 must_die_on_failure=yes
678 ;;
679 merge)
680 command="git merge"
681 die_msg="$(eval_gettext "Unable to merge '\$sha1' in submodule path '\$displaypath'")"
682 say_msg="$(eval_gettext "Submodule path '\$displaypath': merged in '\$sha1'")"
683 must_die_on_failure=yes
684 ;;
685 !*)
686 command="${update_module#!}"
687 die_msg="$(eval_gettext "Execution of '\$command \$sha1' failed in submodule path '\$displaypath'")"
688 say_msg="$(eval_gettext "Submodule path '\$displaypath': '\$command \$sha1'")"
689 must_die_on_failure=yes
690 ;;
691 *)
692 die "$(eval_gettext "Invalid update mode '$update_module' for submodule '$name'")"
693 esac
694 if (sanitize_submodule_env; cd "$sm_path" && $command "$sha1")
696 then
697 say "$say_msg"
698 elif test -n "$must_die_on_failure"
699 then
700 die_with_status 2 "$die_msg"
701 else
702 err="${err};$die_msg"
703 continue
704 fi
705 fi
706 if test -n "$recursive"
708 then
709 (
710 prefix=$(relative_path "$prefix$sm_path/")
711 wt_prefix=
712 sanitize_submodule_env
713 cd "$sm_path" &&
714 eval cmd_update
715 )
716 res=$?
717 if test $res -gt 0
718 then
719 die_msg="$(eval_gettext "Failed to recurse into submodule path '\$displaypath'")"
720 if test $res -eq 1
721 then
722 err="${err};$die_msg"
723 continue
724 else
725 die_with_status $res "$die_msg"
726 fi
727 fi
728 fi
729 done
730 if test -n "$err"
732 then
733 OIFS=$IFS
734 IFS=';'
735 for e in $err
736 do
737 if test -n "$e"
738 then
739 echo >&2 "$e"
740 fi
741 done
742 IFS=$OIFS
743 exit 1
744 fi
745 }
746}
747set_name_rev () {
749 revname=$( (
750 sanitize_submodule_env
751 cd "$1" && {
752 git describe "$2" 2>/dev/null ||
753 git describe --tags "$2" 2>/dev/null ||
754 git describe --contains "$2" 2>/dev/null ||
755 git describe --all --always "$2"
756 }
757 ) )
758 test -z "$revname" || revname=" ($revname)"
759}
760#
761# Show commit summary for submodules in index or working tree
762#
763# If '--cached' is given, show summary between index and given commit,
764# or between working tree and given commit
765#
766# $@ = [commit (default 'HEAD'),] requested paths (default all)
767#
768cmd_summary() {
769 summary_limit=-1
770 for_status=
771 diff_cmd=diff-index
772 # parse $args after "submodule ... summary".
774 while test $# -ne 0
775 do
776 case "$1" in
777 --cached)
778 cached="$1"
779 ;;
780 --files)
781 files="$1"
782 ;;
783 --for-status)
784 for_status="$1"
785 ;;
786 -n|--summary-limit)
787 summary_limit="$2"
788 isnumber "$summary_limit" || usage
789 shift
790 ;;
791 --summary-limit=*)
792 summary_limit="${1#--summary-limit=}"
793 isnumber "$summary_limit" || usage
794 ;;
795 --)
796 shift
797 break
798 ;;
799 -*)
800 usage
801 ;;
802 *)
803 break
804 ;;
805 esac
806 shift
807 done
808 test $summary_limit = 0 && return
810 if rev=$(git rev-parse -q --verify --default HEAD ${1+"$1"})
812 then
813 head=$rev
814 test $# = 0 || shift
815 elif test -z "$1" || test "$1" = "HEAD"
816 then
817 # before the first commit: compare with an empty tree
818 head=$(git hash-object -w -t tree --stdin </dev/null)
819 test -z "$1" || shift
820 else
821 head="HEAD"
822 fi
823 if [ -n "$files" ]
825 then
826 test -n "$cached" &&
827 die "$(gettext "The --cached option cannot be used with the --files option")"
828 diff_cmd=diff-files
829 head=
830 fi
831 cd_to_toplevel
833 eval "set $(git rev-parse --sq --prefix "$wt_prefix" -- "$@")"
834 # Get modified modules cared by user
835 modules=$(git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- "$@" |
836 sane_egrep '^:([0-7]* )?160000' |
837 while read mod_src mod_dst sha1_src sha1_dst status sm_path
838 do
839 # Always show modules deleted or type-changed (blob<->module)
840 if test "$status" = D || test "$status" = T
841 then
842 printf '%s\n' "$sm_path"
843 continue
844 fi
845 # Respect the ignore setting for --for-status.
846 if test -n "$for_status"
847 then
848 name=$(git submodule--helper name "$sm_path")
849 ignore_config=$(get_submodule_config "$name" ignore none)
850 test $status != A && test $ignore_config = all && continue
851 fi
852 # Also show added or modified modules which are checked out
853 GIT_DIR="$sm_path/.git" git-rev-parse --git-dir >/dev/null 2>&1 &&
854 printf '%s\n' "$sm_path"
855 done
856 )
857 test -z "$modules" && return
859 git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- $modules |
861 sane_egrep '^:([0-7]* )?160000' |
862 cut -c2- |
863 while read mod_src mod_dst sha1_src sha1_dst status name
864 do
865 if test -z "$cached" &&
866 test $sha1_dst = 0000000000000000000000000000000000000000
867 then
868 case "$mod_dst" in
869 160000)
870 sha1_dst=$(GIT_DIR="$name/.git" git rev-parse HEAD)
871 ;;
872 100644 | 100755 | 120000)
873 sha1_dst=$(git hash-object $name)
874 ;;
875 000000)
876 ;; # removed
877 *)
878 # unexpected type
879 eval_gettextln "unexpected mode \$mod_dst" >&2
880 continue ;;
881 esac
882 fi
883 missing_src=
884 missing_dst=
885 test $mod_src = 160000 &&
887 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_src^0 >/dev/null &&
888 missing_src=t
889 test $mod_dst = 160000 &&
891 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_dst^0 >/dev/null &&
892 missing_dst=t
893 display_name=$(relative_path "$name")
895 total_commits=
897 case "$missing_src,$missing_dst" in
898 t,)
899 errmsg="$(eval_gettext " Warn: \$display_name doesn't contain commit \$sha1_src")"
900 ;;
901 ,t)
902 errmsg="$(eval_gettext " Warn: \$display_name doesn't contain commit \$sha1_dst")"
903 ;;
904 t,t)
905 errmsg="$(eval_gettext " Warn: \$display_name doesn't contain commits \$sha1_src and \$sha1_dst")"
906 ;;
907 *)
908 errmsg=
909 total_commits=$(
910 if test $mod_src = 160000 && test $mod_dst = 160000
911 then
912 range="$sha1_src...$sha1_dst"
913 elif test $mod_src = 160000
914 then
915 range=$sha1_src
916 else
917 range=$sha1_dst
918 fi
919 GIT_DIR="$name/.git" \
920 git rev-list --first-parent $range -- | wc -l
921 )
922 total_commits=" ($(($total_commits + 0)))"
923 ;;
924 esac
925 sha1_abbr_src=$(echo $sha1_src | cut -c1-7)
927 sha1_abbr_dst=$(echo $sha1_dst | cut -c1-7)
928 if test $status = T
929 then
930 blob="$(gettext "blob")"
931 submodule="$(gettext "submodule")"
932 if test $mod_dst = 160000
933 then
934 echo "* $display_name $sha1_abbr_src($blob)->$sha1_abbr_dst($submodule)$total_commits:"
935 else
936 echo "* $display_name $sha1_abbr_src($submodule)->$sha1_abbr_dst($blob)$total_commits:"
937 fi
938 else
939 echo "* $display_name $sha1_abbr_src...$sha1_abbr_dst$total_commits:"
940 fi
941 if test -n "$errmsg"
942 then
943 # Don't give error msg for modification whose dst is not submodule
944 # i.e. deleted or changed to blob
945 test $mod_dst = 160000 && echo "$errmsg"
946 else
947 if test $mod_src = 160000 && test $mod_dst = 160000
948 then
949 limit=
950 test $summary_limit -gt 0 && limit="-$summary_limit"
951 GIT_DIR="$name/.git" \
952 git log $limit --pretty='format: %m %s' \
953 --first-parent $sha1_src...$sha1_dst
954 elif test $mod_dst = 160000
955 then
956 GIT_DIR="$name/.git" \
957 git log --pretty='format: > %s' -1 $sha1_dst
958 else
959 GIT_DIR="$name/.git" \
960 git log --pretty='format: < %s' -1 $sha1_src
961 fi
962 echo
963 fi
964 echo
965 done
966}
967#
968# List all submodules, prefixed with:
969# - submodule not initialized
970# + different revision checked out
971#
972# If --cached was specified the revision in the index will be printed
973# instead of the currently checked out revision.
974#
975# $@ = requested paths (default to all)
976#
977cmd_status()
978{
979 # parse $args after "submodule ... status".
980 while test $# -ne 0
981 do
982 case "$1" in
983 -q|--quiet)
984 GIT_QUIET=1
985 ;;
986 --cached)
987 cached=1
988 ;;
989 --recursive)
990 recursive=1
991 ;;
992 --)
993 shift
994 break
995 ;;
996 -*)
997 usage
998 ;;
999 *)
1000 break
1001 ;;
1002 esac
1003 shift
1004 done
1005 git submodule--helper list --prefix "$wt_prefix" "$@" |
1007 while read mode sha1 stage sm_path
1008 do
1009 die_if_unmatched "$mode"
1010 name=$(git submodule--helper name "$sm_path") || exit
1011 url=$(git config submodule."$name".url)
1012 displaypath=$(relative_path "$prefix$sm_path")
1013 if test "$stage" = U
1014 then
1015 say "U$sha1 $displaypath"
1016 continue
1017 fi
1018 if test -z "$url" ||
1019 {
1020 ! test -d "$sm_path"/.git &&
1021 ! test -f "$sm_path"/.git
1022 }
1023 then
1024 say "-$sha1 $displaypath"
1025 continue;
1026 fi
1027 if git diff-files --ignore-submodules=dirty --quiet -- "$sm_path"
1028 then
1029 set_name_rev "$sm_path" "$sha1"
1030 say " $sha1 $displaypath$revname"
1031 else
1032 if test -z "$cached"
1033 then
1034 sha1=$(sanitize_submodule_env; cd "$sm_path" && git rev-parse --verify HEAD)
1035 fi
1036 set_name_rev "$sm_path" "$sha1"
1037 say "+$sha1 $displaypath$revname"
1038 fi
1039 if test -n "$recursive"
1041 then
1042 (
1043 prefix="$displaypath/"
1044 sanitize_submodule_env
1045 wt_prefix=
1046 cd "$sm_path" &&
1047 eval cmd_status
1048 ) ||
1049 die "$(eval_gettext "Failed to recurse into submodule path '\$sm_path'")"
1050 fi
1051 done
1052}
1053#
1054# Sync remote urls for submodules
1055# This makes the value for remote.$remote.url match the value
1056# specified in .gitmodules.
1057#
1058cmd_sync()
1059{
1060 while test $# -ne 0
1061 do
1062 case "$1" in
1063 -q|--quiet)
1064 GIT_QUIET=1
1065 shift
1066 ;;
1067 --recursive)
1068 recursive=1
1069 shift
1070 ;;
1071 --)
1072 shift
1073 break
1074 ;;
1075 -*)
1076 usage
1077 ;;
1078 *)
1079 break
1080 ;;
1081 esac
1082 done
1083 cd_to_toplevel
1084 git submodule--helper list --prefix "$wt_prefix" "$@" |
1085 while read mode sha1 stage sm_path
1086 do
1087 die_if_unmatched "$mode"
1088 name=$(git submodule--helper name "$sm_path")
1089 url=$(git config -f .gitmodules --get submodule."$name".url)
1090 # Possibly a url relative to parent
1092 case "$url" in
1093 ./*|../*)
1094 # rewrite foo/bar as ../.. to find path from
1095 # submodule work tree to superproject work tree
1096 up_path="$(printf '%s\n' "$sm_path" | sed "s/[^/][^/]*/../g")" &&
1097 # guarantee a trailing /
1098 up_path=${up_path%/}/ &&
1099 # path from submodule work tree to submodule origin repo
1100 sub_origin_url=$(git submodule--helper resolve-relative-url "$url" "$up_path") &&
1101 # path from superproject work tree to submodule origin repo
1102 super_config_url=$(git submodule--helper resolve-relative-url "$url") || exit
1103 ;;
1104 *)
1105 sub_origin_url="$url"
1106 super_config_url="$url"
1107 ;;
1108 esac
1109 if git config "submodule.$name.url" >/dev/null 2>/dev/null
1111 then
1112 displaypath=$(relative_path "$prefix$sm_path")
1113 say "$(eval_gettext "Synchronizing submodule url for '\$displaypath'")"
1114 git config submodule."$name".url "$super_config_url"
1115 if test -e "$sm_path"/.git
1117 then
1118 (
1119 sanitize_submodule_env
1120 cd "$sm_path"
1121 remote=$(get_default_remote)
1122 git config remote."$remote".url "$sub_origin_url"
1123 if test -n "$recursive"
1125 then
1126 prefix="$prefix$sm_path/"
1127 eval cmd_sync
1128 fi
1129 )
1130 fi
1131 fi
1132 done
1133}
1134# This loop parses the command line arguments to find the
1136# subcommand name to dispatch. Parsing of the subcommand specific
1137# options are primarily done by the subcommand implementations.
1138# Subcommand specific options such as --branch and --cached are
1139# parsed here as well, for backward compatibility.
1140while test $# != 0 && test -z "$command"
1142do
1143 case "$1" in
1144 add | foreach | init | deinit | update | status | summary | sync)
1145 command=$1
1146 ;;
1147 -q|--quiet)
1148 GIT_QUIET=1
1149 ;;
1150 -b|--branch)
1151 case "$2" in
1152 '')
1153 usage
1154 ;;
1155 esac
1156 branch="$2"; shift
1157 ;;
1158 --cached)
1159 cached="$1"
1160 ;;
1161 --)
1162 break
1163 ;;
1164 -*)
1165 usage
1166 ;;
1167 *)
1168 break
1169 ;;
1170 esac
1171 shift
1172done
1173# No command word defaults to "status"
1175if test -z "$command"
1176then
1177 if test $# = 0
1178 then
1179 command=status
1180 else
1181 usage
1182 fi
1183fi
1184# "-b branch" is accepted only by "add"
1186if test -n "$branch" && test "$command" != add
1187then
1188 usage
1189fi
1190# "--cached" is accepted only by "status" and "summary"
1192if test -n "$cached" && test "$command" != status && test "$command" != summary
1193then
1194 usage
1195fi
1196"cmd_$command" "$@"