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 # Turn each leading "*/" component into "../"
172 rel=$(echo $b | sed -e 's|[^/][^/]*|..|g')
173 echo "gitdir: $rel/$a" >"$sm_path/.git"
174 rel=$(echo $a | sed -e 's|[^/][^/]*|..|g')
176 (clear_local_git_env; cd "$sm_path" && GIT_WORK_TREE=. git config core.worktree "$rel/$b")
177}
178#
180# Add a new submodule to the working tree, .gitmodules and the index
181#
182# $@ = repo path
183#
184# optional branch is stored in global branch variable
185#
186cmd_add()
187{
188 # parse $args after "submodule ... add".
189 while test $# -ne 0
190 do
191 case "$1" in
192 -b | --branch)
193 case "$2" in '') usage ;; esac
194 branch=$2
195 shift
196 ;;
197 -f | --force)
198 force=$1
199 ;;
200 -q|--quiet)
201 GIT_QUIET=1
202 ;;
203 --reference)
204 case "$2" in '') usage ;; esac
205 reference="--reference=$2"
206 shift
207 ;;
208 --reference=*)
209 reference="$1"
210 shift
211 ;;
212 --)
213 shift
214 break
215 ;;
216 -*)
217 usage
218 ;;
219 *)
220 break
221 ;;
222 esac
223 shift
224 done
225 repo=$1
227 sm_path=$2
228 if test -z "$sm_path"; then
230 sm_path=$(echo "$repo" |
231 sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
232 fi
233 if test -z "$repo" -o -z "$sm_path"; then
235 usage
236 fi
237 # assure repo is absolute or relative to parent
239 case "$repo" in
240 ./*|../*)
241 # dereference source url relative to parent's url
242 realrepo=$(resolve_relative_url "$repo") || exit
243 ;;
244 *:*|/*)
245 # absolute url
246 realrepo=$repo
247 ;;
248 *)
249 die "$(eval_gettext "repo URL: '\$repo' must be absolute or begin with ./|../")"
250 ;;
251 esac
252 # normalize path:
254 # multiple //; leading ./; /./; /../; trailing /
255 sm_path=$(printf '%s/\n' "$sm_path" |
256 sed -e '
257 s|//*|/|g
258 s|^\(\./\)*||
259 s|/\./|/|g
260 :start
261 s|\([^/]*\)/\.\./||
262 tstart
263 s|/*$||
264 ')
265 git ls-files --error-unmatch "$sm_path" > /dev/null 2>&1 &&
266 die "$(eval_gettext "'\$sm_path' already exists in the index")"
267 if test -z "$force" && ! git add --dry-run --ignore-missing "$sm_path" > /dev/null 2>&1
269 then
270 eval_gettextln "The following path is ignored by one of your .gitignore files:
271\$sm_path
272Use -f if you really want to add it." >&2
273 exit 1
274 fi
275 # perhaps the path exists and is already a git repo, else clone it
277 if test -e "$sm_path"
278 then
279 if test -d "$sm_path"/.git -o -f "$sm_path"/.git
280 then
281 eval_gettextln "Adding existing repo at '\$sm_path' to the index"
282 else
283 die "$(eval_gettext "'\$sm_path' already exists and is not a valid git repo")"
284 fi
285 else
287 module_clone "$sm_path" "$realrepo" "$reference" || exit
289 (
290 clear_local_git_env
291 cd "$sm_path" &&
292 # ash fails to wordsplit ${branch:+-b "$branch"...}
293 case "$branch" in
294 '') git checkout -f -q ;;
295 ?*) git checkout -f -q -B "$branch" "origin/$branch" ;;
296 esac
297 ) || die "$(eval_gettext "Unable to checkout submodule '\$sm_path'")"
298 fi
299 git config submodule."$sm_path".url "$realrepo"
300 git add $force "$sm_path" ||
302 die "$(eval_gettext "Failed to add submodule '\$sm_path'")"
303 git config -f .gitmodules submodule."$sm_path".path "$sm_path" &&
305 git config -f .gitmodules submodule."$sm_path".url "$repo" &&
306 git add --force .gitmodules ||
307 die "$(eval_gettext "Failed to register submodule '\$sm_path'")"
308}
309#
311# Execute an arbitrary command sequence in each checked out
312# submodule
313#
314# $@ = command to execute
315#
316cmd_foreach()
317{
318 # parse $args after "submodule ... foreach".
319 while test $# -ne 0
320 do
321 case "$1" in
322 -q|--quiet)
323 GIT_QUIET=1
324 ;;
325 --recursive)
326 recursive=1
327 ;;
328 -*)
329 usage
330 ;;
331 *)
332 break
333 ;;
334 esac
335 shift
336 done
337 toplevel=$(pwd)
339 # dup stdin so that it can be restored when running the external
341 # command in the subshell (and a recursive call to this function)
342 exec 3<&0
343 module_list |
345 while read mode sha1 stage sm_path
346 do
347 if test -e "$sm_path"/.git
348 then
349 say "$(eval_gettext "Entering '\$prefix\$sm_path'")"
350 name=$(module_name "$sm_path")
351 (
352 prefix="$prefix$sm_path/"
353 clear_local_git_env
354 # we make $path available to scripts ...
355 path=$sm_path
356 cd "$sm_path" &&
357 eval "$@" &&
358 if test -n "$recursive"
359 then
360 cmd_foreach "--recursive" "$@"
361 fi
362 ) <&3 3<&- ||
363 die "$(eval_gettext "Stopping at '\$sm_path'; script returned non-zero status.")"
364 fi
365 done
366}
367#
369# Register submodules in .git/config
370#
371# $@ = requested paths (default to all)
372#
373cmd_init()
374{
375 # parse $args after "submodule ... init".
376 while test $# -ne 0
377 do
378 case "$1" in
379 -q|--quiet)
380 GIT_QUIET=1
381 ;;
382 --)
383 shift
384 break
385 ;;
386 -*)
387 usage
388 ;;
389 *)
390 break
391 ;;
392 esac
393 shift
394 done
395 module_list "$@" |
397 while read mode sha1 stage sm_path
398 do
399 name=$(module_name "$sm_path") || exit
400 # Copy url setting when it is not set yet
402 if test -z "$(git config "submodule.$name.url")"
403 then
404 url=$(git config -f .gitmodules submodule."$name".url)
405 test -z "$url" &&
406 die "$(eval_gettext "No url found for submodule path '\$sm_path' in .gitmodules")"
407 # Possibly a url relative to parent
409 case "$url" in
410 ./*|../*)
411 url=$(resolve_relative_url "$url") || exit
412 ;;
413 esac
414 git config submodule."$name".url "$url" ||
415 die "$(eval_gettext "Failed to register url for submodule path '\$sm_path'")"
416 say "$(eval_gettext "Submodule '\$name' (\$url) registered for path '\$sm_path'")"
418 fi
419 # Copy "update" setting when it is not set yet
421 upd="$(git config -f .gitmodules submodule."$name".update)"
422 test -z "$upd" ||
423 test -n "$(git config submodule."$name".update)" ||
424 git config submodule."$name".update "$upd" ||
425 die "$(eval_gettext "Failed to register update mode for submodule path '\$sm_path'")"
426 done
427}
428#
430# Update each submodule path to correct revision, using clone and checkout as needed
431#
432# $@ = requested paths (default to all)
433#
434cmd_update()
435{
436 # parse $args after "submodule ... update".
437 orig_flags=
438 while test $# -ne 0
439 do
440 case "$1" in
441 -q|--quiet)
442 GIT_QUIET=1
443 ;;
444 -i|--init)
445 init=1
446 ;;
447 -N|--no-fetch)
448 nofetch=1
449 ;;
450 -f|--force)
451 force=$1
452 ;;
453 -r|--rebase)
454 update="rebase"
455 ;;
456 --reference)
457 case "$2" in '') usage ;; esac
458 reference="--reference=$2"
459 orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
460 shift
461 ;;
462 --reference=*)
463 reference="$1"
464 ;;
465 -m|--merge)
466 update="merge"
467 ;;
468 --recursive)
469 recursive=1
470 ;;
471 --checkout)
472 update="checkout"
473 ;;
474 --)
475 shift
476 break
477 ;;
478 -*)
479 usage
480 ;;
481 *)
482 break
483 ;;
484 esac
485 orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
486 shift
487 done
488 if test -n "$init"
490 then
491 cmd_init "--" "$@" || return
492 fi
493 cloned_modules=
495 module_list "$@" | {
496 err=
497 while read mode sha1 stage sm_path
498 do
499 if test "$stage" = U
500 then
501 echo >&2 "Skipping unmerged submodule $sm_path"
502 continue
503 fi
504 name=$(module_name "$sm_path") || exit
505 url=$(git config submodule."$name".url)
506 if ! test -z "$update"
507 then
508 update_module=$update
509 else
510 update_module=$(git config submodule."$name".update)
511 fi
512 if test "$update_module" = "none"
514 then
515 echo "Skipping submodule '$sm_path'"
516 continue
517 fi
518 if test -z "$url"
520 then
521 # Only mention uninitialized submodules when its
522 # path have been specified
523 test "$#" != "0" &&
524 say "$(eval_gettext "Submodule path '\$sm_path' not initialized
525Maybe you want to use 'update --init'?")"
526 continue
527 fi
528 if ! test -d "$sm_path"/.git -o -f "$sm_path"/.git
530 then
531 module_clone "$sm_path" "$url" "$reference"|| exit
532 cloned_modules="$cloned_modules;$name"
533 subsha1=
534 else
535 subsha1=$(clear_local_git_env; cd "$sm_path" &&
536 git rev-parse --verify HEAD) ||
537 die "$(eval_gettext "Unable to find current revision in submodule path '\$sm_path'")"
538 fi
539 if test "$subsha1" != "$sha1"
541 then
542 subforce=$force
543 # If we don't already have a -f flag and the submodule has never been checked out
544 if test -z "$subsha1" -a -z "$force"
545 then
546 subforce="-f"
547 fi
548 if test -z "$nofetch"
550 then
551 # Run fetch only if $sha1 isn't present or it
552 # is not reachable from a ref.
553 (clear_local_git_env; cd "$sm_path" &&
554 ( (rev=$(git rev-list -n 1 $sha1 --not --all 2>/dev/null) &&
555 test -z "$rev") || git-fetch)) ||
556 die "$(eval_gettext "Unable to fetch in submodule path '\$sm_path'")"
557 fi
558 # Is this something we just cloned?
560 case ";$cloned_modules;" in
561 *";$name;"*)
562 # then there is no local change to integrate
563 update_module= ;;
564 esac
565 must_die_on_failure=
567 case "$update_module" in
568 rebase)
569 command="git rebase"
570 die_msg="$(eval_gettext "Unable to rebase '\$sha1' in submodule path '\$sm_path'")"
571 say_msg="$(eval_gettext "Submodule path '\$sm_path': rebased into '\$sha1'")"
572 must_die_on_failure=yes
573 ;;
574 merge)
575 command="git merge"
576 die_msg="$(eval_gettext "Unable to merge '\$sha1' in submodule path '\$sm_path'")"
577 say_msg="$(eval_gettext "Submodule path '\$sm_path': merged in '\$sha1'")"
578 must_die_on_failure=yes
579 ;;
580 *)
581 command="git checkout $subforce -q"
582 die_msg="$(eval_gettext "Unable to checkout '\$sha1' in submodule path '\$sm_path'")"
583 say_msg="$(eval_gettext "Submodule path '\$sm_path': checked out '\$sha1'")"
584 ;;
585 esac
586 if (clear_local_git_env; cd "$sm_path" && $command "$sha1")
588 then
589 say "$say_msg"
590 elif test -n "$must_die_on_failure"
591 then
592 die_with_status 2 "$die_msg"
593 else
594 err="${err};$die_msg"
595 continue
596 fi
597 fi
598 if test -n "$recursive"
600 then
601 (clear_local_git_env; cd "$sm_path" && eval cmd_update "$orig_flags")
602 res=$?
603 if test $res -gt 0
604 then
605 die_msg="$(eval_gettext "Failed to recurse into submodule path '\$sm_path'")"
606 if test $res -eq 1
607 then
608 err="${err};$die_msg"
609 continue
610 else
611 die_with_status $res "$die_msg"
612 fi
613 fi
614 fi
615 done
616 if test -n "$err"
618 then
619 OIFS=$IFS
620 IFS=';'
621 for e in $err
622 do
623 if test -n "$e"
624 then
625 echo >&2 "$e"
626 fi
627 done
628 IFS=$OIFS
629 exit 1
630 fi
631 }
632}
633set_name_rev () {
635 revname=$( (
636 clear_local_git_env
637 cd "$1" && {
638 git describe "$2" 2>/dev/null ||
639 git describe --tags "$2" 2>/dev/null ||
640 git describe --contains "$2" 2>/dev/null ||
641 git describe --all --always "$2"
642 }
643 ) )
644 test -z "$revname" || revname=" ($revname)"
645}
646#
647# Show commit summary for submodules in index or working tree
648#
649# If '--cached' is given, show summary between index and given commit,
650# or between working tree and given commit
651#
652# $@ = [commit (default 'HEAD'),] requested paths (default all)
653#
654cmd_summary() {
655 summary_limit=-1
656 for_status=
657 diff_cmd=diff-index
658 # parse $args after "submodule ... summary".
660 while test $# -ne 0
661 do
662 case "$1" in
663 --cached)
664 cached="$1"
665 ;;
666 --files)
667 files="$1"
668 ;;
669 --for-status)
670 for_status="$1"
671 ;;
672 -n|--summary-limit)
673 if summary_limit=$(($2 + 0)) 2>/dev/null && test "$summary_limit" = "$2"
674 then
675 :
676 else
677 usage
678 fi
679 shift
680 ;;
681 --)
682 shift
683 break
684 ;;
685 -*)
686 usage
687 ;;
688 *)
689 break
690 ;;
691 esac
692 shift
693 done
694 test $summary_limit = 0 && return
696 if rev=$(git rev-parse -q --verify --default HEAD ${1+"$1"})
698 then
699 head=$rev
700 test $# = 0 || shift
701 elif test -z "$1" -o "$1" = "HEAD"
702 then
703 # before the first commit: compare with an empty tree
704 head=$(git hash-object -w -t tree --stdin </dev/null)
705 test -z "$1" || shift
706 else
707 head="HEAD"
708 fi
709 if [ -n "$files" ]
711 then
712 test -n "$cached" &&
713 die "$(gettext -- "--cached cannot be used with --files")"
714 diff_cmd=diff-files
715 head=
716 fi
717 cd_to_toplevel
719 # Get modified modules cared by user
720 modules=$(git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- "$@" |
721 sane_egrep '^:([0-7]* )?160000' |
722 while read mod_src mod_dst sha1_src sha1_dst status name
723 do
724 # Always show modules deleted or type-changed (blob<->module)
725 test $status = D -o $status = T && echo "$name" && continue
726 # Also show added or modified modules which are checked out
727 GIT_DIR="$name/.git" git-rev-parse --git-dir >/dev/null 2>&1 &&
728 echo "$name"
729 done
730 )
731 test -z "$modules" && return
733 git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- $modules |
735 sane_egrep '^:([0-7]* )?160000' |
736 cut -c2- |
737 while read mod_src mod_dst sha1_src sha1_dst status name
738 do
739 if test -z "$cached" &&
740 test $sha1_dst = 0000000000000000000000000000000000000000
741 then
742 case "$mod_dst" in
743 160000)
744 sha1_dst=$(GIT_DIR="$name/.git" git rev-parse HEAD)
745 ;;
746 100644 | 100755 | 120000)
747 sha1_dst=$(git hash-object $name)
748 ;;
749 000000)
750 ;; # removed
751 *)
752 # unexpected type
753 eval_gettextln "unexpected mode \$mod_dst" >&2
754 continue ;;
755 esac
756 fi
757 missing_src=
758 missing_dst=
759 test $mod_src = 160000 &&
761 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_src^0 >/dev/null &&
762 missing_src=t
763 test $mod_dst = 160000 &&
765 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_dst^0 >/dev/null &&
766 missing_dst=t
767 total_commits=
769 case "$missing_src,$missing_dst" in
770 t,)
771 errmsg="$(eval_gettext " Warn: \$name doesn't contain commit \$sha1_src")"
772 ;;
773 ,t)
774 errmsg="$(eval_gettext " Warn: \$name doesn't contain commit \$sha1_dst")"
775 ;;
776 t,t)
777 errmsg="$(eval_gettext " Warn: \$name doesn't contain commits \$sha1_src and \$sha1_dst")"
778 ;;
779 *)
780 errmsg=
781 total_commits=$(
782 if test $mod_src = 160000 -a $mod_dst = 160000
783 then
784 range="$sha1_src...$sha1_dst"
785 elif test $mod_src = 160000
786 then
787 range=$sha1_src
788 else
789 range=$sha1_dst
790 fi
791 GIT_DIR="$name/.git" \
792 git rev-list --first-parent $range -- | wc -l
793 )
794 total_commits=" ($(($total_commits + 0)))"
795 ;;
796 esac
797 sha1_abbr_src=$(echo $sha1_src | cut -c1-7)
799 sha1_abbr_dst=$(echo $sha1_dst | cut -c1-7)
800 if test $status = T
801 then
802 blob="$(gettext "blob")"
803 submodule="$(gettext "submodule")"
804 if test $mod_dst = 160000
805 then
806 echo "* $name $sha1_abbr_src($blob)->$sha1_abbr_dst($submodule)$total_commits:"
807 else
808 echo "* $name $sha1_abbr_src($submodule)->$sha1_abbr_dst($blob)$total_commits:"
809 fi
810 else
811 echo "* $name $sha1_abbr_src...$sha1_abbr_dst$total_commits:"
812 fi
813 if test -n "$errmsg"
814 then
815 # Don't give error msg for modification whose dst is not submodule
816 # i.e. deleted or changed to blob
817 test $mod_dst = 160000 && echo "$errmsg"
818 else
819 if test $mod_src = 160000 -a $mod_dst = 160000
820 then
821 limit=
822 test $summary_limit -gt 0 && limit="-$summary_limit"
823 GIT_DIR="$name/.git" \
824 git log $limit --pretty='format: %m %s' \
825 --first-parent $sha1_src...$sha1_dst
826 elif test $mod_dst = 160000
827 then
828 GIT_DIR="$name/.git" \
829 git log --pretty='format: > %s' -1 $sha1_dst
830 else
831 GIT_DIR="$name/.git" \
832 git log --pretty='format: < %s' -1 $sha1_src
833 fi
834 echo
835 fi
836 echo
837 done |
838 if test -n "$for_status"; then
839 if [ -n "$files" ]; then
840 gettextln "# Submodules changed but not updated:"
841 else
842 gettextln "# Submodule changes to be committed:"
843 fi
844 echo "#"
845 sed -e 's|^|# |' -e 's|^# $|#|'
846 else
847 cat
848 fi
849}
850#
851# List all submodules, prefixed with:
852# - submodule not initialized
853# + different revision checked out
854#
855# If --cached was specified the revision in the index will be printed
856# instead of the currently checked out revision.
857#
858# $@ = requested paths (default to all)
859#
860cmd_status()
861{
862 # parse $args after "submodule ... status".
863 orig_flags=
864 while test $# -ne 0
865 do
866 case "$1" in
867 -q|--quiet)
868 GIT_QUIET=1
869 ;;
870 --cached)
871 cached=1
872 ;;
873 --recursive)
874 recursive=1
875 ;;
876 --)
877 shift
878 break
879 ;;
880 -*)
881 usage
882 ;;
883 *)
884 break
885 ;;
886 esac
887 orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
888 shift
889 done
890 module_list "$@" |
892 while read mode sha1 stage sm_path
893 do
894 name=$(module_name "$sm_path") || exit
895 url=$(git config submodule."$name".url)
896 displaypath="$prefix$sm_path"
897 if test "$stage" = U
898 then
899 say "U$sha1 $displaypath"
900 continue
901 fi
902 if test -z "$url" || ! test -d "$sm_path"/.git -o -f "$sm_path"/.git
903 then
904 say "-$sha1 $displaypath"
905 continue;
906 fi
907 set_name_rev "$sm_path" "$sha1"
908 if git diff-files --ignore-submodules=dirty --quiet -- "$sm_path"
909 then
910 say " $sha1 $displaypath$revname"
911 else
912 if test -z "$cached"
913 then
914 sha1=$(clear_local_git_env; cd "$sm_path" && git rev-parse --verify HEAD)
915 set_name_rev "$sm_path" "$sha1"
916 fi
917 say "+$sha1 $displaypath$revname"
918 fi
919 if test -n "$recursive"
921 then
922 (
923 prefix="$displaypath/"
924 clear_local_git_env
925 cd "$sm_path" &&
926 eval cmd_status "$orig_args"
927 ) ||
928 die "$(eval_gettext "Failed to recurse into submodule path '\$sm_path'")"
929 fi
930 done
931}
932#
933# Sync remote urls for submodules
934# This makes the value for remote.$remote.url match the value
935# specified in .gitmodules.
936#
937cmd_sync()
938{
939 while test $# -ne 0
940 do
941 case "$1" in
942 -q|--quiet)
943 GIT_QUIET=1
944 shift
945 ;;
946 --)
947 shift
948 break
949 ;;
950 -*)
951 usage
952 ;;
953 *)
954 break
955 ;;
956 esac
957 done
958 cd_to_toplevel
959 module_list "$@" |
960 while read mode sha1 stage sm_path
961 do
962 name=$(module_name "$sm_path")
963 url=$(git config -f .gitmodules --get submodule."$name".url)
964 # Possibly a url relative to parent
966 case "$url" in
967 ./*|../*)
968 url=$(resolve_relative_url "$url") || exit
969 ;;
970 esac
971 if git config "submodule.$name.url" >/dev/null 2>/dev/null
973 then
974 say "$(eval_gettext "Synchronizing submodule url for '\$name'")"
975 git config submodule."$name".url "$url"
976 if test -e "$sm_path"/.git
978 then
979 (
980 clear_local_git_env
981 cd "$sm_path"
982 remote=$(get_default_remote)
983 git config remote."$remote".url "$url"
984 )
985 fi
986 fi
987 done
988}
989# This loop parses the command line arguments to find the
991# subcommand name to dispatch. Parsing of the subcommand specific
992# options are primarily done by the subcommand implementations.
993# Subcommand specific options such as --branch and --cached are
994# parsed here as well, for backward compatibility.
995while test $# != 0 && test -z "$command"
997do
998 case "$1" in
999 add | foreach | init | update | status | summary | sync)
1000 command=$1
1001 ;;
1002 -q|--quiet)
1003 GIT_QUIET=1
1004 ;;
1005 -b|--branch)
1006 case "$2" in
1007 '')
1008 usage
1009 ;;
1010 esac
1011 branch="$2"; shift
1012 ;;
1013 --cached)
1014 cached="$1"
1015 ;;
1016 --)
1017 break
1018 ;;
1019 -*)
1020 usage
1021 ;;
1022 *)
1023 break
1024 ;;
1025 esac
1026 shift
1027done
1028# No command word defaults to "status"
1030test -n "$command" || command=status
1031# "-b branch" is accepted only by "add"
1033if test -n "$branch" && test "$command" != add
1034then
1035 usage
1036fi
1037# "--cached" is accepted only by "status" and "summary"
1039if test -n "$cached" && test "$command" != status -a "$command" != summary
1040then
1041 usage
1042fi
1043"cmd_$command" "$@"