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] [--rebase] [--reference <repository>] [--merge] [--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
24command=
26branch=
27force=
28reference=
29cached=
30recursive=
31init=
32files=
33remote=
34nofetch=
35update=
36prefix=
37custom_name=
38# The function takes at most 2 arguments. The first argument is the
40# URL that navigates to the submodule origin repo. When relative, this URL
41# is relative to the superproject origin URL repo. The second up_path
42# argument, if specified, is the relative path that navigates
43# from the submodule working tree to the superproject working tree.
44#
45# The output of the function is the origin URL of the submodule.
46#
47# The output will either be an absolute URL or filesystem path (if the
48# superproject origin URL is an absolute URL or filesystem path,
49# respectively) or a relative file system path (if the superproject
50# origin URL is a relative file system path).
51#
52# When the output is a relative file system path, the path is either
53# relative to the submodule working tree, if up_path is specified, or to
54# the superproject working tree otherwise.
55resolve_relative_url ()
56{
57 remote=$(get_default_remote)
58 remoteurl=$(git config "remote.$remote.url") ||
59 remoteurl=$(pwd) # the repository is its own authoritative upstream
60 url="$1"
61 remoteurl=${remoteurl%/}
62 sep=/
63 up_path="$2"
64 case "$remoteurl" in
66 *:*|/*)
67 is_relative=
68 ;;
69 ./*|../*)
70 is_relative=t
71 ;;
72 *)
73 is_relative=t
74 remoteurl="./$remoteurl"
75 ;;
76 esac
77 while test -n "$url"
79 do
80 case "$url" in
81 ../*)
82 url="${url#../}"
83 case "$remoteurl" in
84 */*)
85 remoteurl="${remoteurl%/*}"
86 ;;
87 *:*)
88 remoteurl="${remoteurl%:*}"
89 sep=:
90 ;;
91 *)
92 if test -z "$is_relative" || test "." = "$remoteurl"
93 then
94 die "$(eval_gettext "cannot strip one component off url '\$remoteurl'")"
95 else
96 remoteurl=.
97 fi
98 ;;
99 esac
100 ;;
101 ./*)
102 url="${url#./}"
103 ;;
104 *)
105 break;;
106 esac
107 done
108 remoteurl="$remoteurl$sep${url%/}"
109 echo "${is_relative:+${up_path}}${remoteurl#./}"
110}
111# Resolve a path to be relative to another path. This is intended for
113# converting submodule paths when git-submodule is run in a subdirectory
114# and only handles paths where the directory separator is '/'.
115#
116# The output is the first argument as a path relative to the second argument,
117# which defaults to $wt_prefix if it is omitted.
118relative_path ()
119{
120 local target curdir result
121 target=$1
122 curdir=${2-$wt_prefix}
123 curdir=${curdir%/}
124 result=
125 while test -n "$curdir"
127 do
128 case "$target" in
129 "$curdir/"*)
130 target=${target#"$curdir"/}
131 break
132 ;;
133 esac
134 result="${result}../"
136 if test "$curdir" = "${curdir%/*}"
137 then
138 curdir=
139 else
140 curdir="${curdir%/*}"
141 fi
142 done
143 echo "$result$target"
145}
146#
148# Get submodule info for registered submodules
149# $@ = path to limit submodule list
150#
151module_list()
152{
153 eval "set $(git rev-parse --sq --prefix "$wt_prefix" -- "$@")"
154 (
155 git ls-files -z --error-unmatch --stage -- "$@" ||
156 echo "unmatched pathspec exists"
157 ) |
158 perl -e '
159 my %unmerged = ();
160 my ($null_sha1) = ("0" x 40);
161 my @out = ();
162 my $unmatched = 0;
163 $/ = "\0";
164 while (<STDIN>) {
165 if (/^unmatched pathspec/) {
166 $unmatched = 1;
167 next;
168 }
169 chomp;
170 my ($mode, $sha1, $stage, $path) =
171 /^([0-7]+) ([0-9a-f]{40}) ([0-3])\t(.*)$/;
172 next unless $mode eq "160000";
173 if ($stage ne "0") {
174 if (!$unmerged{$path}++) {
175 push @out, "$mode $null_sha1 U\t$path\n";
176 }
177 next;
178 }
179 push @out, "$_\n";
180 }
181 if ($unmatched) {
182 print "#unmatched\n";
183 } else {
184 print for (@out);
185 }
186 '
187}
188die_if_unmatched ()
190{
191 if test "$1" = "#unmatched"
192 then
193 exit 1
194 fi
195}
196#
198# Print a submodule configuration setting
199#
200# $1 = submodule name
201# $2 = option name
202# $3 = default value
203#
204# Checks in the usual git-config places first (for overrides),
205# otherwise it falls back on .gitmodules. This allows you to
206# distribute project-wide defaults in .gitmodules, while still
207# customizing individual repositories if necessary. If the option is
208# not in .gitmodules either, print a default value.
209#
210get_submodule_config () {
211 name="$1"
212 option="$2"
213 default="$3"
214 value=$(git config submodule."$name"."$option")
215 if test -z "$value"
216 then
217 value=$(git config -f .gitmodules submodule."$name"."$option")
218 fi
219 printf '%s' "${value:-$default}"
220}
221#
224# Map submodule path to submodule name
225#
226# $1 = path
227#
228module_name()
229{
230 # Do we have "submodule.<something>.path = $1" defined in .gitmodules file?
231 sm_path="$1"
232 re=$(printf '%s\n' "$1" | sed -e 's/[].[^$\\*]/\\&/g')
233 name=$( git config -f .gitmodules --get-regexp '^submodule\..*\.path$' |
234 sed -n -e 's|^submodule\.\(.*\)\.path '"$re"'$|\1|p' )
235 test -z "$name" &&
236 die "$(eval_gettext "No submodule mapping found in .gitmodules for path '\$sm_path'")"
237 echo "$name"
238}
239#
241# Clone a submodule
242#
243# Prior to calling, cmd_update checks that a possibly existing
244# path is not a git repository.
245# Likewise, cmd_add checks that path does not exist at all,
246# since it is the location of a new submodule.
247#
248module_clone()
249{
250 sm_path=$1
251 name=$2
252 url=$3
253 reference="$4"
254 quiet=
255 if test -n "$GIT_QUIET"
256 then
257 quiet=-q
258 fi
259 gitdir=
261 gitdir_base=
262 base_name=$(dirname "$name")
263 gitdir=$(git rev-parse --git-dir)
265 gitdir_base="$gitdir/modules/$base_name"
266 gitdir="$gitdir/modules/$name"
267 if test -d "$gitdir"
269 then
270 mkdir -p "$sm_path"
271 rm -f "$gitdir/index"
272 else
273 mkdir -p "$gitdir_base"
274 (
275 clear_local_git_env
276 git clone $quiet -n ${reference:+"$reference"} \
277 --separate-git-dir "$gitdir" "$url" "$sm_path"
278 ) ||
279 die "$(eval_gettext "Clone of '\$url' into submodule path '\$sm_path' failed")"
280 fi
281 # We already are at the root of the work tree but cd_to_toplevel will
283 # resolve any symlinks that might be present in $PWD
284 a=$(cd_to_toplevel && cd "$gitdir" && pwd)/
285 b=$(cd_to_toplevel && cd "$sm_path" && pwd)/
286 # normalize Windows-style absolute paths to POSIX-style absolute paths
287 case $a in [a-zA-Z]:/*) a=/${a%%:*}${a#*:} ;; esac
288 case $b in [a-zA-Z]:/*) b=/${b%%:*}${b#*:} ;; esac
289 # Remove all common leading directories after a sanity check
290 if test "${a#$b}" != "$a" || test "${b#$a}" != "$b"; then
291 die "$(eval_gettext "Gitdir '\$a' is part of the submodule path '\$b' or vice versa")"
292 fi
293 while test "${a%%/*}" = "${b%%/*}"
294 do
295 a=${a#*/}
296 b=${b#*/}
297 done
298 # Now chop off the trailing '/'s that were added in the beginning
299 a=${a%/}
300 b=${b%/}
301 # Turn each leading "*/" component into "../"
303 rel=$(echo $b | sed -e 's|[^/][^/]*|..|g')
304 echo "gitdir: $rel/$a" >"$sm_path/.git"
305 rel=$(echo $a | sed -e 's|[^/][^/]*|..|g')
307 (clear_local_git_env; cd "$sm_path" && GIT_WORK_TREE=. git config core.worktree "$rel/$b")
308}
309isnumber()
311{
312 n=$(($1 + 0)) 2>/dev/null && test "$n" = "$1"
313}
314#
316# Add a new submodule to the working tree, .gitmodules and the index
317#
318# $@ = repo path
319#
320# optional branch is stored in global branch variable
321#
322cmd_add()
323{
324 # parse $args after "submodule ... add".
325 reference_path=
326 while test $# -ne 0
327 do
328 case "$1" in
329 -b | --branch)
330 case "$2" in '') usage ;; esac
331 branch=$2
332 shift
333 ;;
334 -f | --force)
335 force=$1
336 ;;
337 -q|--quiet)
338 GIT_QUIET=1
339 ;;
340 --reference)
341 case "$2" in '') usage ;; esac
342 reference_path=$2
343 shift
344 ;;
345 --reference=*)
346 reference_path="${1#--reference=}"
347 ;;
348 --name)
349 case "$2" in '') usage ;; esac
350 custom_name=$2
351 shift
352 ;;
353 --)
354 shift
355 break
356 ;;
357 -*)
358 usage
359 ;;
360 *)
361 break
362 ;;
363 esac
364 shift
365 done
366 if test -n "$reference_path"
368 then
369 is_absolute_path "$reference_path" ||
370 reference_path="$wt_prefix$reference_path"
371 reference="--reference=$reference_path"
373 fi
374 repo=$1
376 sm_path=$2
377 if test -z "$sm_path"; then
379 sm_path=$(echo "$repo" |
380 sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
381 fi
382 if test -z "$repo" -o -z "$sm_path"; then
384 usage
385 fi
386 is_absolute_path "$sm_path" || sm_path="$wt_prefix$sm_path"
388 # assure repo is absolute or relative to parent
390 case "$repo" in
391 ./*|../*)
392 test -z "$wt_prefix" ||
393 die "$(gettext "Relative path can only be used from the toplevel of the working tree")"
394 # dereference source url relative to parent's url
396 realrepo=$(resolve_relative_url "$repo") || exit
397 ;;
398 *:*|/*)
399 # absolute url
400 realrepo=$repo
401 ;;
402 *)
403 die "$(eval_gettext "repo URL: '\$repo' must be absolute or begin with ./|../")"
404 ;;
405 esac
406 # normalize path:
408 # multiple //; leading ./; /./; /../; trailing /
409 sm_path=$(printf '%s/\n' "$sm_path" |
410 sed -e '
411 s|//*|/|g
412 s|^\(\./\)*||
413 s|/\./|/|g
414 :start
415 s|\([^/]*\)/\.\./||
416 tstart
417 s|/*$||
418 ')
419 git ls-files --error-unmatch "$sm_path" > /dev/null 2>&1 &&
420 die "$(eval_gettext "'\$sm_path' already exists in the index")"
421 if test -z "$force" && ! git add --dry-run --ignore-missing "$sm_path" > /dev/null 2>&1
423 then
424 eval_gettextln "The following path is ignored by one of your .gitignore files:
425\$sm_path
426Use -f if you really want to add it." >&2
427 exit 1
428 fi
429 if test -n "$custom_name"
431 then
432 sm_name="$custom_name"
433 else
434 sm_name="$sm_path"
435 fi
436 # perhaps the path exists and is already a git repo, else clone it
438 if test -e "$sm_path"
439 then
440 if test -d "$sm_path"/.git -o -f "$sm_path"/.git
441 then
442 eval_gettextln "Adding existing repo at '\$sm_path' to the index"
443 else
444 die "$(eval_gettext "'\$sm_path' already exists and is not a valid git repo")"
445 fi
446 else
448 if test -d ".git/modules/$sm_name"
449 then
450 if test -z "$force"
451 then
452 echo >&2 "$(eval_gettext "A git directory for '\$sm_name' is found locally with remote(s):")"
453 GIT_DIR=".git/modules/$sm_name" GIT_WORK_TREE=. git remote -v | grep '(fetch)' | sed -e s,^," ", -e s,' (fetch)',, >&2
454 echo >&2 "$(eval_gettext "If you want to reuse this local git directory instead of cloning again from")"
455 echo >&2 " $realrepo"
456 echo >&2 "$(eval_gettext "use the '--force' option. If the local git directory is not the correct repo")"
457 die "$(eval_gettext "or you are unsure what this means choose another name with the '--name' option.")"
458 else
459 echo "$(eval_gettext "Reactivating local git directory for submodule '\$sm_name'.")"
460 fi
461 fi
462 module_clone "$sm_path" "$sm_name" "$realrepo" "$reference" || exit
463 (
464 clear_local_git_env
465 cd "$sm_path" &&
466 # ash fails to wordsplit ${branch:+-b "$branch"...}
467 case "$branch" in
468 '') git checkout -f -q ;;
469 ?*) git checkout -f -q -B "$branch" "origin/$branch" ;;
470 esac
471 ) || die "$(eval_gettext "Unable to checkout submodule '\$sm_path'")"
472 fi
473 git config submodule."$sm_name".url "$realrepo"
474 git add $force "$sm_path" ||
476 die "$(eval_gettext "Failed to add submodule '\$sm_path'")"
477 git config -f .gitmodules submodule."$sm_name".path "$sm_path" &&
479 git config -f .gitmodules submodule."$sm_name".url "$repo" &&
480 if test -n "$branch"
481 then
482 git config -f .gitmodules submodule."$sm_name".branch "$branch"
483 fi &&
484 git add --force .gitmodules ||
485 die "$(eval_gettext "Failed to register submodule '\$sm_path'")"
486}
487#
489# Execute an arbitrary command sequence in each checked out
490# submodule
491#
492# $@ = command to execute
493#
494cmd_foreach()
495{
496 # parse $args after "submodule ... foreach".
497 while test $# -ne 0
498 do
499 case "$1" in
500 -q|--quiet)
501 GIT_QUIET=1
502 ;;
503 --recursive)
504 recursive=1
505 ;;
506 -*)
507 usage
508 ;;
509 *)
510 break
511 ;;
512 esac
513 shift
514 done
515 toplevel=$(pwd)
517 # dup stdin so that it can be restored when running the external
519 # command in the subshell (and a recursive call to this function)
520 exec 3<&0
521 module_list |
523 while read mode sha1 stage sm_path
524 do
525 die_if_unmatched "$mode"
526 if test -e "$sm_path"/.git
527 then
528 displaypath=$(relative_path "$sm_path")
529 say "$(eval_gettext "Entering '\$prefix\$displaypath'")"
530 name=$(module_name "$sm_path")
531 (
532 prefix="$prefix$sm_path/"
533 clear_local_git_env
534 cd "$sm_path" &&
535 sm_path=$(relative_path "$sm_path") &&
536 # we make $path available to scripts ...
537 path=$sm_path &&
538 eval "$@" &&
539 if test -n "$recursive"
540 then
541 cmd_foreach "--recursive" "$@"
542 fi
543 ) <&3 3<&- ||
544 die "$(eval_gettext "Stopping at '\$prefix\$displaypath'; script returned non-zero status.")"
545 fi
546 done
547}
548#
550# Register submodules in .git/config
551#
552# $@ = requested paths (default to all)
553#
554cmd_init()
555{
556 # parse $args after "submodule ... init".
557 while test $# -ne 0
558 do
559 case "$1" in
560 -q|--quiet)
561 GIT_QUIET=1
562 ;;
563 --)
564 shift
565 break
566 ;;
567 -*)
568 usage
569 ;;
570 *)
571 break
572 ;;
573 esac
574 shift
575 done
576 module_list "$@" |
578 while read mode sha1 stage sm_path
579 do
580 die_if_unmatched "$mode"
581 name=$(module_name "$sm_path") || exit
582 displaypath=$(relative_path "$sm_path")
584 # Copy url setting when it is not set yet
586 if test -z "$(git config "submodule.$name.url")"
587 then
588 url=$(git config -f .gitmodules submodule."$name".url)
589 test -z "$url" &&
590 die "$(eval_gettext "No url found for submodule path '\$displaypath' in .gitmodules")"
591 # Possibly a url relative to parent
593 case "$url" in
594 ./*|../*)
595 url=$(resolve_relative_url "$url") || exit
596 ;;
597 esac
598 git config submodule."$name".url "$url" ||
599 die "$(eval_gettext "Failed to register url for submodule path '\$displaypath'")"
600 say "$(eval_gettext "Submodule '\$name' (\$url) registered for path '\$displaypath'")"
602 fi
603 # Copy "update" setting when it is not set yet
605 upd="$(git config -f .gitmodules submodule."$name".update)"
606 test -z "$upd" ||
607 test -n "$(git config submodule."$name".update)" ||
608 git config submodule."$name".update "$upd" ||
609 die "$(eval_gettext "Failed to register update mode for submodule path '\$displaypath'")"
610 done
611}
612#
614# Unregister submodules from .git/config and remove their work tree
615#
616# $@ = requested paths (use '.' to deinit all submodules)
617#
618cmd_deinit()
619{
620 # parse $args after "submodule ... deinit".
621 while test $# -ne 0
622 do
623 case "$1" in
624 -f|--force)
625 force=$1
626 ;;
627 -q|--quiet)
628 GIT_QUIET=1
629 ;;
630 --)
631 shift
632 break
633 ;;
634 -*)
635 usage
636 ;;
637 *)
638 break
639 ;;
640 esac
641 shift
642 done
643 if test $# = 0
645 then
646 die "$(eval_gettext "Use '.' if you really want to deinitialize all submodules")"
647 fi
648 module_list "$@" |
650 while read mode sha1 stage sm_path
651 do
652 die_if_unmatched "$mode"
653 name=$(module_name "$sm_path") || exit
654 displaypath=$(relative_path "$sm_path")
656 # Remove the submodule work tree (unless the user already did it)
658 if test -d "$sm_path"
659 then
660 # Protect submodules containing a .git directory
661 if test -d "$sm_path/.git"
662 then
663 echo >&2 "$(eval_gettext "Submodule work tree '\$displaypath' contains a .git directory")"
664 die "$(eval_gettext "(use 'rm -rf' if you really want to remove it including all of its history)")"
665 fi
666 if test -z "$force"
668 then
669 git rm -qn "$sm_path" ||
670 die "$(eval_gettext "Submodule work tree '\$displaypath' contains local modifications; use '-f' to discard them")"
671 fi
672 rm -rf "$sm_path" &&
673 say "$(eval_gettext "Cleared directory '\$displaypath'")" ||
674 say "$(eval_gettext "Could not remove submodule work tree '\$displaypath'")"
675 fi
676 mkdir "$sm_path" || say "$(eval_gettext "Could not create empty submodule directory '\$displaypath'")"
678 # Remove the .git/config entries (unless the user already did it)
680 if test -n "$(git config --get-regexp submodule."$name\.")"
681 then
682 # Remove the whole section so we have a clean state when
683 # the user later decides to init this submodule again
684 url=$(git config submodule."$name".url)
685 git config --remove-section submodule."$name" 2>/dev/null &&
686 say "$(eval_gettext "Submodule '\$name' (\$url) unregistered for path '\$displaypath'")"
687 fi
688 done
689}
690#
692# Update each submodule path to correct revision, using clone and checkout as needed
693#
694# $@ = requested paths (default to all)
695#
696cmd_update()
697{
698 # parse $args after "submodule ... update".
699 orig_flags=
700 while test $# -ne 0
701 do
702 case "$1" in
703 -q|--quiet)
704 GIT_QUIET=1
705 ;;
706 -i|--init)
707 init=1
708 ;;
709 --remote)
710 remote=1
711 ;;
712 -N|--no-fetch)
713 nofetch=1
714 ;;
715 -f|--force)
716 force=$1
717 ;;
718 -r|--rebase)
719 update="rebase"
720 ;;
721 --reference)
722 case "$2" in '') usage ;; esac
723 reference="--reference=$2"
724 orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
725 shift
726 ;;
727 --reference=*)
728 reference="$1"
729 ;;
730 -m|--merge)
731 update="merge"
732 ;;
733 --recursive)
734 recursive=1
735 ;;
736 --checkout)
737 update="checkout"
738 ;;
739 --)
740 shift
741 break
742 ;;
743 -*)
744 usage
745 ;;
746 *)
747 break
748 ;;
749 esac
750 orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
751 shift
752 done
753 if test -n "$init"
755 then
756 cmd_init "--" "$@" || return
757 fi
758 cloned_modules=
760 module_list "$@" | {
761 err=
762 while read mode sha1 stage sm_path
763 do
764 die_if_unmatched "$mode"
765 if test "$stage" = U
766 then
767 echo >&2 "Skipping unmerged submodule $prefix$sm_path"
768 continue
769 fi
770 name=$(module_name "$sm_path") || exit
771 url=$(git config submodule."$name".url)
772 branch=$(get_submodule_config "$name" branch master)
773 if ! test -z "$update"
774 then
775 update_module=$update
776 else
777 update_module=$(git config submodule."$name".update)
778 fi
779 displaypath=$(relative_path "$prefix$sm_path")
781 if test "$update_module" = "none"
783 then
784 echo "Skipping submodule '$displaypath'"
785 continue
786 fi
787 if test -z "$url"
789 then
790 # Only mention uninitialized submodules when its
791 # path have been specified
792 test "$#" != "0" &&
793 say "$(eval_gettext "Submodule path '\$displaypath' not initialized
794Maybe you want to use 'update --init'?")"
795 continue
796 fi
797 if ! test -d "$sm_path"/.git -o -f "$sm_path"/.git
799 then
800 module_clone "$sm_path" "$name" "$url" "$reference" || exit
801 cloned_modules="$cloned_modules;$name"
802 subsha1=
803 else
804 subsha1=$(clear_local_git_env; cd "$sm_path" &&
805 git rev-parse --verify HEAD) ||
806 die "$(eval_gettext "Unable to find current revision in submodule path '\$displaypath'")"
807 fi
808 if test -n "$remote"
810 then
811 if test -z "$nofetch"
812 then
813 # Fetch remote before determining tracking $sha1
814 (clear_local_git_env; cd "$sm_path" && git-fetch) ||
815 die "$(eval_gettext "Unable to fetch in submodule path '\$sm_path'")"
816 fi
817 remote_name=$(clear_local_git_env; cd "$sm_path" && get_default_remote)
818 sha1=$(clear_local_git_env; cd "$sm_path" &&
819 git rev-parse --verify "${remote_name}/${branch}") ||
820 die "$(eval_gettext "Unable to find current ${remote_name}/${branch} revision in submodule path '\$sm_path'")"
821 fi
822 if test "$subsha1" != "$sha1" -o -n "$force"
824 then
825 subforce=$force
826 # If we don't already have a -f flag and the submodule has never been checked out
827 if test -z "$subsha1" -a -z "$force"
828 then
829 subforce="-f"
830 fi
831 if test -z "$nofetch"
833 then
834 # Run fetch only if $sha1 isn't present or it
835 # is not reachable from a ref.
836 (clear_local_git_env; cd "$sm_path" &&
837 ( (rev=$(git rev-list -n 1 $sha1 --not --all 2>/dev/null) &&
838 test -z "$rev") || git-fetch)) ||
839 die "$(eval_gettext "Unable to fetch in submodule path '\$displaypath'")"
840 fi
841 # Is this something we just cloned?
843 case ";$cloned_modules;" in
844 *";$name;"*)
845 # then there is no local change to integrate
846 update_module= ;;
847 esac
848 must_die_on_failure=
850 case "$update_module" in
851 rebase)
852 command="git rebase"
853 die_msg="$(eval_gettext "Unable to rebase '\$sha1' in submodule path '\$displaypath'")"
854 say_msg="$(eval_gettext "Submodule path '\$displaypath': rebased into '\$sha1'")"
855 must_die_on_failure=yes
856 ;;
857 merge)
858 command="git merge"
859 die_msg="$(eval_gettext "Unable to merge '\$sha1' in submodule path '\$displaypath'")"
860 say_msg="$(eval_gettext "Submodule path '\$displaypath': merged in '\$sha1'")"
861 must_die_on_failure=yes
862 ;;
863 *)
864 command="git checkout $subforce -q"
865 die_msg="$(eval_gettext "Unable to checkout '\$sha1' in submodule path '\$displaypath'")"
866 say_msg="$(eval_gettext "Submodule path '\$displaypath': checked out '\$sha1'")"
867 ;;
868 esac
869 if (clear_local_git_env; cd "$sm_path" && $command "$sha1")
871 then
872 say "$say_msg"
873 elif test -n "$must_die_on_failure"
874 then
875 die_with_status 2 "$die_msg"
876 else
877 err="${err};$die_msg"
878 continue
879 fi
880 fi
881 if test -n "$recursive"
883 then
884 (
885 prefix="$prefix$sm_path/"
886 clear_local_git_env
887 cd "$sm_path" &&
888 eval cmd_update "$orig_flags"
889 )
890 res=$?
891 if test $res -gt 0
892 then
893 die_msg="$(eval_gettext "Failed to recurse into submodule path '\$displaypath'")"
894 if test $res -eq 1
895 then
896 err="${err};$die_msg"
897 continue
898 else
899 die_with_status $res "$die_msg"
900 fi
901 fi
902 fi
903 done
904 if test -n "$err"
906 then
907 OIFS=$IFS
908 IFS=';'
909 for e in $err
910 do
911 if test -n "$e"
912 then
913 echo >&2 "$e"
914 fi
915 done
916 IFS=$OIFS
917 exit 1
918 fi
919 }
920}
921set_name_rev () {
923 revname=$( (
924 clear_local_git_env
925 cd "$1" && {
926 git describe "$2" 2>/dev/null ||
927 git describe --tags "$2" 2>/dev/null ||
928 git describe --contains "$2" 2>/dev/null ||
929 git describe --all --always "$2"
930 }
931 ) )
932 test -z "$revname" || revname=" ($revname)"
933}
934#
935# Show commit summary for submodules in index or working tree
936#
937# If '--cached' is given, show summary between index and given commit,
938# or between working tree and given commit
939#
940# $@ = [commit (default 'HEAD'),] requested paths (default all)
941#
942cmd_summary() {
943 summary_limit=-1
944 for_status=
945 diff_cmd=diff-index
946 # parse $args after "submodule ... summary".
948 while test $# -ne 0
949 do
950 case "$1" in
951 --cached)
952 cached="$1"
953 ;;
954 --files)
955 files="$1"
956 ;;
957 --for-status)
958 for_status="$1"
959 ;;
960 -n|--summary-limit)
961 summary_limit="$2"
962 isnumber "$summary_limit" || usage
963 shift
964 ;;
965 --summary-limit=*)
966 summary_limit="${1#--summary-limit=}"
967 isnumber "$summary_limit" || usage
968 ;;
969 --)
970 shift
971 break
972 ;;
973 -*)
974 usage
975 ;;
976 *)
977 break
978 ;;
979 esac
980 shift
981 done
982 test $summary_limit = 0 && return
984 if rev=$(git rev-parse -q --verify --default HEAD ${1+"$1"})
986 then
987 head=$rev
988 test $# = 0 || shift
989 elif test -z "$1" -o "$1" = "HEAD"
990 then
991 # before the first commit: compare with an empty tree
992 head=$(git hash-object -w -t tree --stdin </dev/null)
993 test -z "$1" || shift
994 else
995 head="HEAD"
996 fi
997 if [ -n "$files" ]
999 then
1000 test -n "$cached" &&
1001 die "$(gettext "The --cached option cannot be used with the --files option")"
1002 diff_cmd=diff-files
1003 head=
1004 fi
1005 cd_to_toplevel
1007 eval "set $(git rev-parse --sq --prefix "$wt_prefix" -- "$@")"
1008 # Get modified modules cared by user
1009 modules=$(git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- "$@" |
1010 sane_egrep '^:([0-7]* )?160000' |
1011 while read mod_src mod_dst sha1_src sha1_dst status name
1012 do
1013 # Always show modules deleted or type-changed (blob<->module)
1014 test $status = D -o $status = T && echo "$name" && continue
1015 # Also show added or modified modules which are checked out
1016 GIT_DIR="$name/.git" git-rev-parse --git-dir >/dev/null 2>&1 &&
1017 echo "$name"
1018 done
1019 )
1020 test -z "$modules" && return
1022 git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- $modules |
1024 sane_egrep '^:([0-7]* )?160000' |
1025 cut -c2- |
1026 while read mod_src mod_dst sha1_src sha1_dst status name
1027 do
1028 if test -z "$cached" &&
1029 test $sha1_dst = 0000000000000000000000000000000000000000
1030 then
1031 case "$mod_dst" in
1032 160000)
1033 sha1_dst=$(GIT_DIR="$name/.git" git rev-parse HEAD)
1034 ;;
1035 100644 | 100755 | 120000)
1036 sha1_dst=$(git hash-object $name)
1037 ;;
1038 000000)
1039 ;; # removed
1040 *)
1041 # unexpected type
1042 eval_gettextln "unexpected mode \$mod_dst" >&2
1043 continue ;;
1044 esac
1045 fi
1046 missing_src=
1047 missing_dst=
1048 test $mod_src = 160000 &&
1050 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_src^0 >/dev/null &&
1051 missing_src=t
1052 test $mod_dst = 160000 &&
1054 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_dst^0 >/dev/null &&
1055 missing_dst=t
1056 display_name=$(relative_path "$name")
1058 total_commits=
1060 case "$missing_src,$missing_dst" in
1061 t,)
1062 errmsg="$(eval_gettext " Warn: \$display_name doesn't contain commit \$sha1_src")"
1063 ;;
1064 ,t)
1065 errmsg="$(eval_gettext " Warn: \$display_name doesn't contain commit \$sha1_dst")"
1066 ;;
1067 t,t)
1068 errmsg="$(eval_gettext " Warn: \$display_name doesn't contain commits \$sha1_src and \$sha1_dst")"
1069 ;;
1070 *)
1071 errmsg=
1072 total_commits=$(
1073 if test $mod_src = 160000 -a $mod_dst = 160000
1074 then
1075 range="$sha1_src...$sha1_dst"
1076 elif test $mod_src = 160000
1077 then
1078 range=$sha1_src
1079 else
1080 range=$sha1_dst
1081 fi
1082 GIT_DIR="$name/.git" \
1083 git rev-list --first-parent $range -- | wc -l
1084 )
1085 total_commits=" ($(($total_commits + 0)))"
1086 ;;
1087 esac
1088 sha1_abbr_src=$(echo $sha1_src | cut -c1-7)
1090 sha1_abbr_dst=$(echo $sha1_dst | cut -c1-7)
1091 if test $status = T
1092 then
1093 blob="$(gettext "blob")"
1094 submodule="$(gettext "submodule")"
1095 if test $mod_dst = 160000
1096 then
1097 echo "* $display_name $sha1_abbr_src($blob)->$sha1_abbr_dst($submodule)$total_commits:"
1098 else
1099 echo "* $display_name $sha1_abbr_src($submodule)->$sha1_abbr_dst($blob)$total_commits:"
1100 fi
1101 else
1102 echo "* $display_name $sha1_abbr_src...$sha1_abbr_dst$total_commits:"
1103 fi
1104 if test -n "$errmsg"
1105 then
1106 # Don't give error msg for modification whose dst is not submodule
1107 # i.e. deleted or changed to blob
1108 test $mod_dst = 160000 && echo "$errmsg"
1109 else
1110 if test $mod_src = 160000 -a $mod_dst = 160000
1111 then
1112 limit=
1113 test $summary_limit -gt 0 && limit="-$summary_limit"
1114 GIT_DIR="$name/.git" \
1115 git log $limit --pretty='format: %m %s' \
1116 --first-parent $sha1_src...$sha1_dst
1117 elif test $mod_dst = 160000
1118 then
1119 GIT_DIR="$name/.git" \
1120 git log --pretty='format: > %s' -1 $sha1_dst
1121 else
1122 GIT_DIR="$name/.git" \
1123 git log --pretty='format: < %s' -1 $sha1_src
1124 fi
1125 echo
1126 fi
1127 echo
1128 done |
1129 if test -n "$for_status"; then
1130 if [ -n "$files" ]; then
1131 gettextln "Submodules changed but not updated:" | git stripspace -c
1132 else
1133 gettextln "Submodule changes to be committed:" | git stripspace -c
1134 fi
1135 printf "\n" | git stripspace -c
1136 git stripspace -c
1137 else
1138 cat
1139 fi
1140}
1141#
1142# List all submodules, prefixed with:
1143# - submodule not initialized
1144# + different revision checked out
1145#
1146# If --cached was specified the revision in the index will be printed
1147# instead of the currently checked out revision.
1148#
1149# $@ = requested paths (default to all)
1150#
1151cmd_status()
1152{
1153 # parse $args after "submodule ... status".
1154 while test $# -ne 0
1155 do
1156 case "$1" in
1157 -q|--quiet)
1158 GIT_QUIET=1
1159 ;;
1160 --cached)
1161 cached=1
1162 ;;
1163 --recursive)
1164 recursive=1
1165 ;;
1166 --)
1167 shift
1168 break
1169 ;;
1170 -*)
1171 usage
1172 ;;
1173 *)
1174 break
1175 ;;
1176 esac
1177 shift
1178 done
1179 module_list "$@" |
1181 while read mode sha1 stage sm_path
1182 do
1183 die_if_unmatched "$mode"
1184 name=$(module_name "$sm_path") || exit
1185 url=$(git config submodule."$name".url)
1186 displaypath=$(relative_path "$prefix$sm_path")
1187 if test "$stage" = U
1188 then
1189 say "U$sha1 $displaypath"
1190 continue
1191 fi
1192 if test -z "$url" || ! test -d "$sm_path"/.git -o -f "$sm_path"/.git
1193 then
1194 say "-$sha1 $displaypath"
1195 continue;
1196 fi
1197 if git diff-files --ignore-submodules=dirty --quiet -- "$sm_path"
1198 then
1199 set_name_rev "$sm_path" "$sha1"
1200 say " $sha1 $displaypath$revname"
1201 else
1202 if test -z "$cached"
1203 then
1204 sha1=$(clear_local_git_env; cd "$sm_path" && git rev-parse --verify HEAD)
1205 fi
1206 set_name_rev "$sm_path" "$sha1"
1207 say "+$sha1 $displaypath$revname"
1208 fi
1209 if test -n "$recursive"
1211 then
1212 (
1213 prefix="$displaypath/"
1214 clear_local_git_env
1215 cd "$sm_path" &&
1216 eval cmd_status
1217 ) ||
1218 die "$(eval_gettext "Failed to recurse into submodule path '\$sm_path'")"
1219 fi
1220 done
1221}
1222#
1223# Sync remote urls for submodules
1224# This makes the value for remote.$remote.url match the value
1225# specified in .gitmodules.
1226#
1227cmd_sync()
1228{
1229 while test $# -ne 0
1230 do
1231 case "$1" in
1232 -q|--quiet)
1233 GIT_QUIET=1
1234 shift
1235 ;;
1236 --recursive)
1237 recursive=1
1238 shift
1239 ;;
1240 --)
1241 shift
1242 break
1243 ;;
1244 -*)
1245 usage
1246 ;;
1247 *)
1248 break
1249 ;;
1250 esac
1251 done
1252 cd_to_toplevel
1253 module_list "$@" |
1254 while read mode sha1 stage sm_path
1255 do
1256 die_if_unmatched "$mode"
1257 name=$(module_name "$sm_path")
1258 url=$(git config -f .gitmodules --get submodule."$name".url)
1259 # Possibly a url relative to parent
1261 case "$url" in
1262 ./*|../*)
1263 # rewrite foo/bar as ../.. to find path from
1264 # submodule work tree to superproject work tree
1265 up_path="$(echo "$sm_path" | sed "s/[^/][^/]*/../g")" &&
1266 # guarantee a trailing /
1267 up_path=${up_path%/}/ &&
1268 # path from submodule work tree to submodule origin repo
1269 sub_origin_url=$(resolve_relative_url "$url" "$up_path") &&
1270 # path from superproject work tree to submodule origin repo
1271 super_config_url=$(resolve_relative_url "$url") || exit
1272 ;;
1273 *)
1274 sub_origin_url="$url"
1275 super_config_url="$url"
1276 ;;
1277 esac
1278 if git config "submodule.$name.url" >/dev/null 2>/dev/null
1280 then
1281 displaypath=$(relative_path "$prefix$sm_path")
1282 say "$(eval_gettext "Synchronizing submodule url for '\$displaypath'")"
1283 git config submodule."$name".url "$super_config_url"
1284 if test -e "$sm_path"/.git
1286 then
1287 (
1288 clear_local_git_env
1289 cd "$sm_path"
1290 remote=$(get_default_remote)
1291 git config remote."$remote".url "$sub_origin_url"
1292 if test -n "$recursive"
1294 then
1295 prefix="$prefix$sm_path/"
1296 eval cmd_sync
1297 fi
1298 )
1299 fi
1300 fi
1301 done
1302}
1303# This loop parses the command line arguments to find the
1305# subcommand name to dispatch. Parsing of the subcommand specific
1306# options are primarily done by the subcommand implementations.
1307# Subcommand specific options such as --branch and --cached are
1308# parsed here as well, for backward compatibility.
1309while test $# != 0 && test -z "$command"
1311do
1312 case "$1" in
1313 add | foreach | init | deinit | update | status | summary | sync)
1314 command=$1
1315 ;;
1316 -q|--quiet)
1317 GIT_QUIET=1
1318 ;;
1319 -b|--branch)
1320 case "$2" in
1321 '')
1322 usage
1323 ;;
1324 esac
1325 branch="$2"; shift
1326 ;;
1327 --cached)
1328 cached="$1"
1329 ;;
1330 --)
1331 break
1332 ;;
1333 -*)
1334 usage
1335 ;;
1336 *)
1337 break
1338 ;;
1339 esac
1340 shift
1341done
1342# No command word defaults to "status"
1344if test -z "$command"
1345then
1346 if test $# = 0
1347 then
1348 command=status
1349 else
1350 usage
1351 fi
1352fi
1353# "-b branch" is accepted only by "add"
1355if test -n "$branch" && test "$command" != add
1356then
1357 usage
1358fi
1359# "--cached" is accepted only by "status" and "summary"
1361if test -n "$cached" && test "$command" != status -a "$command" != summary
1362then
1363 usage
1364fi
1365"cmd_$command" "$@"