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