1#!/bin/sh
2#
3# git-submodules.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] [--reference <repository>] [--] <repository> [<path>]
9 or: $dashless [--quiet] status [--cached] [--recursive] [--] [<path>...]
10 or: $dashless [--quiet] init [--] [<path>...]
11 or: $dashless [--quiet] update [--init] [-N|--no-fetch] [-f|--force] [--rebase] [--reference <repository>] [--merge] [--recursive] [--] [<path>...]
12 or: $dashless [--quiet] summary [--cached|--files] [--summary-limit <n>] [commit] [--] [<path>...]
13 or: $dashless [--quiet] foreach [--recursive] <command>
14 or: $dashless [--quiet] sync [--] [<path>...]"
15OPTIONS_SPEC=
16. git-sh-setup
17. git-sh-i18n
18. git-parse-remote
19require_work_tree
20command=
22branch=
23force=
24reference=
25cached=
26recursive=
27init=
28files=
29nofetch=
30update=
31prefix=
32# Resolve relative url by appending to parent's url
34resolve_relative_url ()
35{
36 remote=$(get_default_remote)
37 remoteurl=$(git config "remote.$remote.url") ||
38 remoteurl=$(pwd) # the repository is its own authoritative upstream
39 url="$1"
40 remoteurl=${remoteurl%/}
41 sep=/
42 while test -n "$url"
43 do
44 case "$url" in
45 ../*)
46 url="${url#../}"
47 case "$remoteurl" in
48 */*)
49 remoteurl="${remoteurl%/*}"
50 ;;
51 *:*)
52 remoteurl="${remoteurl%:*}"
53 sep=:
54 ;;
55 *)
56 die "$(eval_gettext "cannot strip one component off url '\$remoteurl'")"
57 ;;
58 esac
59 ;;
60 ./*)
61 url="${url#./}"
62 ;;
63 *)
64 break;;
65 esac
66 done
67 echo "$remoteurl$sep${url%/}"
68}
69#
71# Get submodule info for registered submodules
72# $@ = path to limit submodule list
73#
74module_list()
75{
76 git ls-files --error-unmatch --stage -- "$@" |
77 perl -e '
78 my %unmerged = ();
79 my ($null_sha1) = ("0" x 40);
80 while (<STDIN>) {
81 chomp;
82 my ($mode, $sha1, $stage, $path) =
83 /^([0-7]+) ([0-9a-f]{40}) ([0-3])\t(.*)$/;
84 next unless $mode eq "160000";
85 if ($stage ne "0") {
86 if (!$unmerged{$path}++) {
87 print "$mode $null_sha1 U\t$path\n";
88 }
89 next;
90 }
91 print "$_\n";
92 }
93 '
94}
95#
97# Map submodule path to submodule name
98#
99# $1 = path
100#
101module_name()
102{
103 # Do we have "submodule.<something>.path = $1" defined in .gitmodules file?
104 sm_path="$1"
105 re=$(printf '%s\n' "$1" | sed -e 's/[].[^$\\*]/\\&/g')
106 name=$( git config -f .gitmodules --get-regexp '^submodule\..*\.path$' |
107 sed -n -e 's|^submodule\.\(.*\)\.path '"$re"'$|\1|p' )
108 test -z "$name" &&
109 die "$(eval_gettext "No submodule mapping found in .gitmodules for path '\$sm_path'")"
110 echo "$name"
111}
112#
114# Clone a submodule
115#
116# Prior to calling, cmd_update checks that a possibly existing
117# path is not a git repository.
118# Likewise, cmd_add checks that path does not exist at all,
119# since it is the location of a new submodule.
120#
121module_clone()
122{
123 sm_path=$1
124 url=$2
125 reference="$3"
126 quiet=
127 if test -n "$GIT_QUIET"
128 then
129 quiet=-q
130 fi
131 gitdir=
133 gitdir_base=
134 name=$(module_name "$sm_path" 2>/dev/null)
135 test -n "$name" || name="$sm_path"
136 base_name=$(dirname "$name")
137 gitdir=$(git rev-parse --git-dir)
139 gitdir_base="$gitdir/modules/$base_name"
140 gitdir="$gitdir/modules/$name"
141 if test -d "$gitdir"
143 then
144 mkdir -p "$sm_path"
145 rm -f "$gitdir/index"
146 else
147 mkdir -p "$gitdir_base"
148 git clone $quiet -n ${reference:+"$reference"} \
149 --separate-git-dir "$gitdir" "$url" "$sm_path" ||
150 die "$(eval_gettext "Clone of '\$url' into submodule path '\$sm_path' failed")"
151 fi
152 a=$(cd "$gitdir" && pwd)/
154 b=$(cd "$sm_path" && pwd)/
155 # normalize Windows-style absolute paths to POSIX-style absolute paths
156 case $a in [a-zA-Z]:/*) a=/${a%%:*}${a#*:} ;; esac
157 case $b in [a-zA-Z]:/*) b=/${b%%:*}${b#*:} ;; esac
158 # Remove all common leading directories after a sanity check
159 if test "${a#$b}" != "$a" || test "${b#$a}" != "$b"; then
160 die "$(eval_gettext "Gitdir '\$a' is part of the submodule path '\$b' or vice versa")"
161 fi
162 while test "${a%%/*}" = "${b%%/*}"
163 do
164 a=${a#*/}
165 b=${b#*/}
166 done
167 # Now chop off the trailing '/'s that were added in the beginning
168 a=${a%/}
169 b=${b%/}
170 rel=$(echo $b | sed -e 's|[^/]*|..|g')
172 echo "gitdir: $rel/$a" >"$sm_path/.git"
173 rel=$(echo $a | sed -e 's|[^/]*|..|g')
175 (clear_local_git_env; cd "$sm_path" && GIT_WORK_TREE=. git config core.worktree "$rel/$b")
176}
177#
179# Add a new submodule to the working tree, .gitmodules and the index
180#
181# $@ = repo path
182#
183# optional branch is stored in global branch variable
184#
185cmd_add()
186{
187 # parse $args after "submodule ... add".
188 while test $# -ne 0
189 do
190 case "$1" in
191 -b | --branch)
192 case "$2" in '') usage ;; esac
193 branch=$2
194 shift
195 ;;
196 -f | --force)
197 force=$1
198 ;;
199 -q|--quiet)
200 GIT_QUIET=1
201 ;;
202 --reference)
203 case "$2" in '') usage ;; esac
204 reference="--reference=$2"
205 shift
206 ;;
207 --reference=*)
208 reference="$1"
209 shift
210 ;;
211 --)
212 shift
213 break
214 ;;
215 -*)
216 usage
217 ;;
218 *)
219 break
220 ;;
221 esac
222 shift
223 done
224 repo=$1
226 sm_path=$2
227 if test -z "$sm_path"; then
229 sm_path=$(echo "$repo" |
230 sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
231 fi
232 if test -z "$repo" -o -z "$sm_path"; then
234 usage
235 fi
236 # assure repo is absolute or relative to parent
238 case "$repo" in
239 ./*|../*)
240 # dereference source url relative to parent's url
241 realrepo=$(resolve_relative_url "$repo") || exit
242 ;;
243 *:*|/*)
244 # absolute url
245 realrepo=$repo
246 ;;
247 *)
248 die "$(eval_gettext "repo URL: '\$repo' must be absolute or begin with ./|../")"
249 ;;
250 esac
251 # normalize path:
253 # multiple //; leading ./; /./; /../; trailing /
254 sm_path=$(printf '%s/\n' "$sm_path" |
255 sed -e '
256 s|//*|/|g
257 s|^\(\./\)*||
258 s|/\./|/|g
259 :start
260 s|\([^/]*\)/\.\./||
261 tstart
262 s|/*$||
263 ')
264 git ls-files --error-unmatch "$sm_path" > /dev/null 2>&1 &&
265 die "$(eval_gettext "'\$sm_path' already exists in the index")"
266 if test -z "$force" && ! git add --dry-run --ignore-missing "$sm_path" > /dev/null 2>&1
268 then
269 eval_gettextln "The following path is ignored by one of your .gitignore files:
270\$sm_path
271Use -f if you really want to add it." >&2
272 exit 1
273 fi
274 # perhaps the path exists and is already a git repo, else clone it
276 if test -e "$sm_path"
277 then
278 if test -d "$sm_path"/.git -o -f "$sm_path"/.git
279 then
280 eval_gettextln "Adding existing repo at '\$sm_path' to the index"
281 else
282 die "$(eval_gettext "'\$sm_path' already exists and is not a valid git repo")"
283 fi
284 else
286 module_clone "$sm_path" "$realrepo" "$reference" || exit
288 (
289 clear_local_git_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_path".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_path".path "$sm_path" &&
304 git config -f .gitmodules submodule."$sm_path".url "$repo" &&
305 git add --force .gitmodules ||
306 die "$(eval_gettext "Failed to register submodule '\$sm_path'")"
307}
308#
310# Execute an arbitrary command sequence in each checked out
311# submodule
312#
313# $@ = command to execute
314#
315cmd_foreach()
316{
317 # parse $args after "submodule ... foreach".
318 while test $# -ne 0
319 do
320 case "$1" in
321 -q|--quiet)
322 GIT_QUIET=1
323 ;;
324 --recursive)
325 recursive=1
326 ;;
327 -*)
328 usage
329 ;;
330 *)
331 break
332 ;;
333 esac
334 shift
335 done
336 toplevel=$(pwd)
338 # dup stdin so that it can be restored when running the external
340 # command in the subshell (and a recursive call to this function)
341 exec 3<&0
342 module_list |
344 while read mode sha1 stage sm_path
345 do
346 if test -e "$sm_path"/.git
347 then
348 say "$(eval_gettext "Entering '\$prefix\$sm_path'")"
349 name=$(module_name "$sm_path")
350 (
351 prefix="$prefix$sm_path/"
352 clear_local_git_env
353 # we make $path available to scripts ...
354 path=$sm_path
355 cd "$sm_path" &&
356 eval "$@" &&
357 if test -n "$recursive"
358 then
359 cmd_foreach "--recursive" "$@"
360 fi
361 ) <&3 3<&- ||
362 die "$(eval_gettext "Stopping at '\$sm_path'; script returned non-zero status.")"
363 fi
364 done
365}
366#
368# Register submodules in .git/config
369#
370# $@ = requested paths (default to all)
371#
372cmd_init()
373{
374 # parse $args after "submodule ... init".
375 while test $# -ne 0
376 do
377 case "$1" in
378 -q|--quiet)
379 GIT_QUIET=1
380 ;;
381 --)
382 shift
383 break
384 ;;
385 -*)
386 usage
387 ;;
388 *)
389 break
390 ;;
391 esac
392 shift
393 done
394 module_list "$@" |
396 while read mode sha1 stage sm_path
397 do
398 # Skip already registered paths
399 name=$(module_name "$sm_path") || exit
400 if test -z "$(git config "submodule.$name.url")"
401 then
402 url=$(git config -f .gitmodules submodule."$name".url)
403 test -z "$url" &&
404 die "$(eval_gettext "No url found for submodule path '\$sm_path' in .gitmodules")"
405 # Possibly a url relative to parent
407 case "$url" in
408 ./*|../*)
409 url=$(resolve_relative_url "$url") || exit
410 ;;
411 esac
412 git config submodule."$name".url "$url" ||
413 die "$(eval_gettext "Failed to register url for submodule path '\$sm_path'")"
414 fi
415 # Copy "update" setting when it is not set yet
417 upd="$(git config -f .gitmodules submodule."$name".update)"
418 test -z "$upd" ||
419 test -n "$(git config submodule."$name".update)" ||
420 git config submodule."$name".update "$upd" ||
421 die "$(eval_gettext "Failed to register update mode for submodule path '\$sm_path'")"
422 say "$(eval_gettext "Submodule '\$name' (\$url) registered for path '\$sm_path'")"
424 done
425}
426#
428# Update each submodule path to correct revision, using clone and checkout as needed
429#
430# $@ = requested paths (default to all)
431#
432cmd_update()
433{
434 # parse $args after "submodule ... update".
435 orig_flags=
436 while test $# -ne 0
437 do
438 case "$1" in
439 -q|--quiet)
440 GIT_QUIET=1
441 ;;
442 -i|--init)
443 init=1
444 ;;
445 -N|--no-fetch)
446 nofetch=1
447 ;;
448 -f|--force)
449 force=$1
450 ;;
451 -r|--rebase)
452 update="rebase"
453 ;;
454 --reference)
455 case "$2" in '') usage ;; esac
456 reference="--reference=$2"
457 orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
458 shift
459 ;;
460 --reference=*)
461 reference="$1"
462 ;;
463 -m|--merge)
464 update="merge"
465 ;;
466 --recursive)
467 recursive=1
468 ;;
469 --checkout)
470 update="checkout"
471 ;;
472 --)
473 shift
474 break
475 ;;
476 -*)
477 usage
478 ;;
479 *)
480 break
481 ;;
482 esac
483 orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
484 shift
485 done
486 if test -n "$init"
488 then
489 cmd_init "--" "$@" || return
490 fi
491 cloned_modules=
493 module_list "$@" | {
494 err=
495 while read mode sha1 stage sm_path
496 do
497 if test "$stage" = U
498 then
499 echo >&2 "Skipping unmerged submodule $sm_path"
500 continue
501 fi
502 name=$(module_name "$sm_path") || exit
503 url=$(git config submodule."$name".url)
504 if ! test -z "$update"
505 then
506 update_module=$update
507 else
508 update_module=$(git config submodule."$name".update)
509 fi
510 if test "$update_module" = "none"
512 then
513 echo "Skipping submodule '$sm_path'"
514 continue
515 fi
516 if test -z "$url"
518 then
519 # Only mention uninitialized submodules when its
520 # path have been specified
521 test "$#" != "0" &&
522 say "$(eval_gettext "Submodule path '\$sm_path' not initialized
523Maybe you want to use 'update --init'?")"
524 continue
525 fi
526 if ! test -d "$sm_path"/.git -o -f "$sm_path"/.git
528 then
529 module_clone "$sm_path" "$url" "$reference"|| exit
530 cloned_modules="$cloned_modules;$name"
531 subsha1=
532 else
533 subsha1=$(clear_local_git_env; cd "$sm_path" &&
534 git rev-parse --verify HEAD) ||
535 die "$(eval_gettext "Unable to find current revision in submodule path '\$sm_path'")"
536 fi
537 if test "$subsha1" != "$sha1"
539 then
540 subforce=$force
541 # If we don't already have a -f flag and the submodule has never been checked out
542 if test -z "$subsha1" -a -z "$force"
543 then
544 subforce="-f"
545 fi
546 if test -z "$nofetch"
548 then
549 # Run fetch only if $sha1 isn't present or it
550 # is not reachable from a ref.
551 (clear_local_git_env; cd "$sm_path" &&
552 ( (rev=$(git rev-list -n 1 $sha1 --not --all 2>/dev/null) &&
553 test -z "$rev") || git-fetch)) ||
554 die "$(eval_gettext "Unable to fetch in submodule path '\$sm_path'")"
555 fi
556 # Is this something we just cloned?
558 case ";$cloned_modules;" in
559 *";$name;"*)
560 # then there is no local change to integrate
561 update_module= ;;
562 esac
563 must_die_on_failure=
565 case "$update_module" in
566 rebase)
567 command="git rebase"
568 die_msg="$(eval_gettext "Unable to rebase '\$sha1' in submodule path '\$sm_path'")"
569 say_msg="$(eval_gettext "Submodule path '\$sm_path': rebased into '\$sha1'")"
570 must_die_on_failure=yes
571 ;;
572 merge)
573 command="git merge"
574 die_msg="$(eval_gettext "Unable to merge '\$sha1' in submodule path '\$sm_path'")"
575 say_msg="$(eval_gettext "Submodule path '\$sm_path': merged in '\$sha1'")"
576 must_die_on_failure=yes
577 ;;
578 *)
579 command="git checkout $subforce -q"
580 die_msg="$(eval_gettext "Unable to checkout '\$sha1' in submodule path '\$sm_path'")"
581 say_msg="$(eval_gettext "Submodule path '\$sm_path': checked out '\$sha1'")"
582 ;;
583 esac
584 if (clear_local_git_env; cd "$sm_path" && $command "$sha1")
586 then
587 say "$say_msg"
588 elif test -n "$must_die_on_failure"
589 then
590 die_with_status 2 "$die_msg"
591 else
592 err="${err};$die_msg"
593 continue
594 fi
595 fi
596 if test -n "$recursive"
598 then
599 (clear_local_git_env; cd "$sm_path" && eval cmd_update "$orig_flags")
600 res=$?
601 if test $res -gt 0
602 then
603 die_msg="$(eval_gettext "Failed to recurse into submodule path '\$sm_path'")"
604 if test $res -eq 1
605 then
606 err="${err};$die_msg"
607 continue
608 else
609 die_with_status $res "$die_msg"
610 fi
611 fi
612 fi
613 done
614 if test -n "$err"
616 then
617 OIFS=$IFS
618 IFS=';'
619 for e in $err
620 do
621 if test -n "$e"
622 then
623 echo >&2 "$e"
624 fi
625 done
626 IFS=$OIFS
627 exit 1
628 fi
629 }
630}
631set_name_rev () {
633 revname=$( (
634 clear_local_git_env
635 cd "$1" && {
636 git describe "$2" 2>/dev/null ||
637 git describe --tags "$2" 2>/dev/null ||
638 git describe --contains "$2" 2>/dev/null ||
639 git describe --all --always "$2"
640 }
641 ) )
642 test -z "$revname" || revname=" ($revname)"
643}
644#
645# Show commit summary for submodules in index or working tree
646#
647# If '--cached' is given, show summary between index and given commit,
648# or between working tree and given commit
649#
650# $@ = [commit (default 'HEAD'),] requested paths (default all)
651#
652cmd_summary() {
653 summary_limit=-1
654 for_status=
655 diff_cmd=diff-index
656 # parse $args after "submodule ... summary".
658 while test $# -ne 0
659 do
660 case "$1" in
661 --cached)
662 cached="$1"
663 ;;
664 --files)
665 files="$1"
666 ;;
667 --for-status)
668 for_status="$1"
669 ;;
670 -n|--summary-limit)
671 if summary_limit=$(($2 + 0)) 2>/dev/null && test "$summary_limit" = "$2"
672 then
673 :
674 else
675 usage
676 fi
677 shift
678 ;;
679 --)
680 shift
681 break
682 ;;
683 -*)
684 usage
685 ;;
686 *)
687 break
688 ;;
689 esac
690 shift
691 done
692 test $summary_limit = 0 && return
694 if rev=$(git rev-parse -q --verify --default HEAD ${1+"$1"})
696 then
697 head=$rev
698 test $# = 0 || shift
699 elif test -z "$1" -o "$1" = "HEAD"
700 then
701 # before the first commit: compare with an empty tree
702 head=$(git hash-object -w -t tree --stdin </dev/null)
703 test -z "$1" || shift
704 else
705 head="HEAD"
706 fi
707 if [ -n "$files" ]
709 then
710 test -n "$cached" &&
711 die "$(gettext -- "--cached cannot be used with --files")"
712 diff_cmd=diff-files
713 head=
714 fi
715 cd_to_toplevel
717 # Get modified modules cared by user
718 modules=$(git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- "$@" |
719 sane_egrep '^:([0-7]* )?160000' |
720 while read mod_src mod_dst sha1_src sha1_dst status name
721 do
722 # Always show modules deleted or type-changed (blob<->module)
723 test $status = D -o $status = T && echo "$name" && continue
724 # Also show added or modified modules which are checked out
725 GIT_DIR="$name/.git" git-rev-parse --git-dir >/dev/null 2>&1 &&
726 echo "$name"
727 done
728 )
729 test -z "$modules" && return
731 git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- $modules |
733 sane_egrep '^:([0-7]* )?160000' |
734 cut -c2- |
735 while read mod_src mod_dst sha1_src sha1_dst status name
736 do
737 if test -z "$cached" &&
738 test $sha1_dst = 0000000000000000000000000000000000000000
739 then
740 case "$mod_dst" in
741 160000)
742 sha1_dst=$(GIT_DIR="$name/.git" git rev-parse HEAD)
743 ;;
744 100644 | 100755 | 120000)
745 sha1_dst=$(git hash-object $name)
746 ;;
747 000000)
748 ;; # removed
749 *)
750 # unexpected type
751 eval_gettextln "unexpected mode \$mod_dst" >&2
752 continue ;;
753 esac
754 fi
755 missing_src=
756 missing_dst=
757 test $mod_src = 160000 &&
759 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_src^0 >/dev/null &&
760 missing_src=t
761 test $mod_dst = 160000 &&
763 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_dst^0 >/dev/null &&
764 missing_dst=t
765 total_commits=
767 case "$missing_src,$missing_dst" in
768 t,)
769 errmsg="$(eval_gettext " Warn: \$name doesn't contain commit \$sha1_src")"
770 ;;
771 ,t)
772 errmsg="$(eval_gettext " Warn: \$name doesn't contain commit \$sha1_dst")"
773 ;;
774 t,t)
775 errmsg="$(eval_gettext " Warn: \$name doesn't contain commits \$sha1_src and \$sha1_dst")"
776 ;;
777 *)
778 errmsg=
779 total_commits=$(
780 if test $mod_src = 160000 -a $mod_dst = 160000
781 then
782 range="$sha1_src...$sha1_dst"
783 elif test $mod_src = 160000
784 then
785 range=$sha1_src
786 else
787 range=$sha1_dst
788 fi
789 GIT_DIR="$name/.git" \
790 git rev-list --first-parent $range -- | wc -l
791 )
792 total_commits=" ($(($total_commits + 0)))"
793 ;;
794 esac
795 sha1_abbr_src=$(echo $sha1_src | cut -c1-7)
797 sha1_abbr_dst=$(echo $sha1_dst | cut -c1-7)
798 if test $status = T
799 then
800 blob="$(gettext "blob")"
801 submodule="$(gettext "submodule")"
802 if test $mod_dst = 160000
803 then
804 echo "* $name $sha1_abbr_src($blob)->$sha1_abbr_dst($submodule)$total_commits:"
805 else
806 echo "* $name $sha1_abbr_src($submodule)->$sha1_abbr_dst($blob)$total_commits:"
807 fi
808 else
809 echo "* $name $sha1_abbr_src...$sha1_abbr_dst$total_commits:"
810 fi
811 if test -n "$errmsg"
812 then
813 # Don't give error msg for modification whose dst is not submodule
814 # i.e. deleted or changed to blob
815 test $mod_dst = 160000 && echo "$errmsg"
816 else
817 if test $mod_src = 160000 -a $mod_dst = 160000
818 then
819 limit=
820 test $summary_limit -gt 0 && limit="-$summary_limit"
821 GIT_DIR="$name/.git" \
822 git log $limit --pretty='format: %m %s' \
823 --first-parent $sha1_src...$sha1_dst
824 elif test $mod_dst = 160000
825 then
826 GIT_DIR="$name/.git" \
827 git log --pretty='format: > %s' -1 $sha1_dst
828 else
829 GIT_DIR="$name/.git" \
830 git log --pretty='format: < %s' -1 $sha1_src
831 fi
832 echo
833 fi
834 echo
835 done |
836 if test -n "$for_status"; then
837 if [ -n "$files" ]; then
838 gettextln "# Submodules changed but not updated:"
839 else
840 gettextln "# Submodule changes to be committed:"
841 fi
842 echo "#"
843 sed -e 's|^|# |' -e 's|^# $|#|'
844 else
845 cat
846 fi
847}
848#
849# List all submodules, prefixed with:
850# - submodule not initialized
851# + different revision checked out
852#
853# If --cached was specified the revision in the index will be printed
854# instead of the currently checked out revision.
855#
856# $@ = requested paths (default to all)
857#
858cmd_status()
859{
860 # parse $args after "submodule ... status".
861 orig_flags=
862 while test $# -ne 0
863 do
864 case "$1" in
865 -q|--quiet)
866 GIT_QUIET=1
867 ;;
868 --cached)
869 cached=1
870 ;;
871 --recursive)
872 recursive=1
873 ;;
874 --)
875 shift
876 break
877 ;;
878 -*)
879 usage
880 ;;
881 *)
882 break
883 ;;
884 esac
885 orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
886 shift
887 done
888 module_list "$@" |
890 while read mode sha1 stage sm_path
891 do
892 name=$(module_name "$sm_path") || exit
893 url=$(git config submodule."$name".url)
894 displaypath="$prefix$sm_path"
895 if test "$stage" = U
896 then
897 say "U$sha1 $displaypath"
898 continue
899 fi
900 if test -z "$url" || ! test -d "$sm_path"/.git -o -f "$sm_path"/.git
901 then
902 say "-$sha1 $displaypath"
903 continue;
904 fi
905 set_name_rev "$sm_path" "$sha1"
906 if git diff-files --ignore-submodules=dirty --quiet -- "$sm_path"
907 then
908 say " $sha1 $displaypath$revname"
909 else
910 if test -z "$cached"
911 then
912 sha1=$(clear_local_git_env; cd "$sm_path" && git rev-parse --verify HEAD)
913 set_name_rev "$sm_path" "$sha1"
914 fi
915 say "+$sha1 $displaypath$revname"
916 fi
917 if test -n "$recursive"
919 then
920 (
921 prefix="$displaypath/"
922 clear_local_git_env
923 cd "$sm_path" &&
924 eval cmd_status "$orig_args"
925 ) ||
926 die "$(eval_gettext "Failed to recurse into submodule path '\$sm_path'")"
927 fi
928 done
929}
930#
931# Sync remote urls for submodules
932# This makes the value for remote.$remote.url match the value
933# specified in .gitmodules.
934#
935cmd_sync()
936{
937 while test $# -ne 0
938 do
939 case "$1" in
940 -q|--quiet)
941 GIT_QUIET=1
942 shift
943 ;;
944 --)
945 shift
946 break
947 ;;
948 -*)
949 usage
950 ;;
951 *)
952 break
953 ;;
954 esac
955 done
956 cd_to_toplevel
957 module_list "$@" |
958 while read mode sha1 stage sm_path
959 do
960 name=$(module_name "$sm_path")
961 url=$(git config -f .gitmodules --get submodule."$name".url)
962 # Possibly a url relative to parent
964 case "$url" in
965 ./*|../*)
966 url=$(resolve_relative_url "$url") || exit
967 ;;
968 esac
969 if git config "submodule.$name.url" >/dev/null 2>/dev/null
971 then
972 say "$(eval_gettext "Synchronizing submodule url for '\$name'")"
973 git config submodule."$name".url "$url"
974 if test -e "$sm_path"/.git
976 then
977 (
978 clear_local_git_env
979 cd "$sm_path"
980 remote=$(get_default_remote)
981 git config remote."$remote".url "$url"
982 )
983 fi
984 fi
985 done
986}
987# This loop parses the command line arguments to find the
989# subcommand name to dispatch. Parsing of the subcommand specific
990# options are primarily done by the subcommand implementations.
991# Subcommand specific options such as --branch and --cached are
992# parsed here as well, for backward compatibility.
993while test $# != 0 && test -z "$command"
995do
996 case "$1" in
997 add | foreach | init | update | status | summary | sync)
998 command=$1
999 ;;
1000 -q|--quiet)
1001 GIT_QUIET=1
1002 ;;
1003 -b|--branch)
1004 case "$2" in
1005 '')
1006 usage
1007 ;;
1008 esac
1009 branch="$2"; shift
1010 ;;
1011 --cached)
1012 cached="$1"
1013 ;;
1014 --)
1015 break
1016 ;;
1017 -*)
1018 usage
1019 ;;
1020 *)
1021 break
1022 ;;
1023 esac
1024 shift
1025done
1026# No command word defaults to "status"
1028test -n "$command" || command=status
1029# "-b branch" is accepted only by "add"
1031if test -n "$branch" && test "$command" != add
1032then
1033 usage
1034fi
1035# "--cached" is accepted only by "status" and "summary"
1037if test -n "$cached" && test "$command" != status -a "$command" != summary
1038then
1039 usage
1040fi
1041"cmd_$command" "$@"