Code

Recent MinGW has a C99 implementation of snprintf functions
[git.git] / git-submodule.sh
1 #!/bin/sh
2 #
3 # git-submodules.sh: add, init, update or list git submodules
4 #
5 # Copyright (c) 2007 Lars Hjemli
7 dashless=$(basename "$0" | sed -e 's/-/ /')
8 USAGE="[--quiet] add [-b branch] [--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] [--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-parse-remote
18 require_work_tree
20 command=
21 branch=
22 reference=
23 cached=
24 recursive=
25 init=
26 files=
27 nofetch=
28 update=
29 prefix=
31 # Resolve relative url by appending to parent's url
32 resolve_relative_url ()
33 {
34         remote=$(get_default_remote)
35         remoteurl=$(git config "remote.$remote.url") ||
36                 die "remote ($remote) does not have a url defined in .git/config"
37         url="$1"
38         remoteurl=${remoteurl%/}
39         while test -n "$url"
40         do
41                 case "$url" in
42                 ../*)
43                         url="${url#../}"
44                         remoteurl="${remoteurl%/*}"
45                         ;;
46                 ./*)
47                         url="${url#./}"
48                         ;;
49                 *)
50                         break;;
51                 esac
52         done
53         echo "$remoteurl/${url%/}"
54 }
56 #
57 # Get submodule info for registered submodules
58 # $@ = path to limit submodule list
59 #
60 module_list()
61 {
62         git ls-files --error-unmatch --stage -- "$@" | sane_grep '^160000 '
63 }
65 #
66 # Map submodule path to submodule name
67 #
68 # $1 = path
69 #
70 module_name()
71 {
72         # Do we have "submodule.<something>.path = $1" defined in .gitmodules file?
73         re=$(printf '%s\n' "$1" | sed -e 's/[].[^$\\*]/\\&/g')
74         name=$( git config -f .gitmodules --get-regexp '^submodule\..*\.path$' |
75                 sed -n -e 's|^submodule\.\(.*\)\.path '"$re"'$|\1|p' )
76        test -z "$name" &&
77        die "No submodule mapping found in .gitmodules for path '$path'"
78        echo "$name"
79 }
81 #
82 # Clone a submodule
83 #
84 # Prior to calling, cmd_update checks that a possibly existing
85 # path is not a git repository.
86 # Likewise, cmd_add checks that path does not exist at all,
87 # since it is the location of a new submodule.
88 #
89 module_clone()
90 {
91         path=$1
92         url=$2
93         reference="$3"
95         # If there already is a directory at the submodule path,
96         # expect it to be empty (since that is the default checkout
97         # action) and try to remove it.
98         # Note: if $path is a symlink to a directory the test will
99         # succeed but the rmdir will fail. We might want to fix this.
100         if test -d "$path"
101         then
102                 rmdir "$path" 2>/dev/null ||
103                 die "Directory '$path' exists, but is neither empty nor a git repository"
104         fi
106         test -e "$path" &&
107         die "A file already exist at path '$path'"
109         if test -n "$reference"
110         then
111                 git-clone "$reference" -n "$url" "$path"
112         else
113                 git-clone -n "$url" "$path"
114         fi ||
115         die "Clone of '$url' into submodule path '$path' failed"
119 # Add a new submodule to the working tree, .gitmodules and the index
121 # $@ = repo path
123 # optional branch is stored in global branch variable
125 cmd_add()
127         # parse $args after "submodule ... add".
128         while test $# -ne 0
129         do
130                 case "$1" in
131                 -b | --branch)
132                         case "$2" in '') usage ;; esac
133                         branch=$2
134                         shift
135                         ;;
136                 -q|--quiet)
137                         GIT_QUIET=1
138                         ;;
139                 --reference)
140                         case "$2" in '') usage ;; esac
141                         reference="--reference=$2"
142                         shift
143                         ;;
144                 --reference=*)
145                         reference="$1"
146                         shift
147                         ;;
148                 --)
149                         shift
150                         break
151                         ;;
152                 -*)
153                         usage
154                         ;;
155                 *)
156                         break
157                         ;;
158                 esac
159                 shift
160         done
162         repo=$1
163         path=$2
165         if test -z "$path"; then
166                 path=$(echo "$repo" |
167                         sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
168         fi
170         if test -z "$repo" -o -z "$path"; then
171                 usage
172         fi
174         # assure repo is absolute or relative to parent
175         case "$repo" in
176         ./*|../*)
177                 # dereference source url relative to parent's url
178                 realrepo=$(resolve_relative_url "$repo") || exit
179                 ;;
180         *:*|/*)
181                 # absolute url
182                 realrepo=$repo
183                 ;;
184         *)
185                 die "repo URL: '$repo' must be absolute or begin with ./|../"
186         ;;
187         esac
189         # normalize path:
190         # multiple //; leading ./; /./; /../; trailing /
191         path=$(printf '%s/\n' "$path" |
192                 sed -e '
193                         s|//*|/|g
194                         s|^\(\./\)*||
195                         s|/\./|/|g
196                         :start
197                         s|\([^/]*\)/\.\./||
198                         tstart
199                         s|/*$||
200                 ')
201         git ls-files --error-unmatch "$path" > /dev/null 2>&1 &&
202         die "'$path' already exists in the index"
204         # perhaps the path exists and is already a git repo, else clone it
205         if test -e "$path"
206         then
207                 if test -d "$path"/.git -o -f "$path"/.git
208                 then
209                         echo "Adding existing repo at '$path' to the index"
210                 else
211                         die "'$path' already exists and is not a valid git repo"
212                 fi
214                 case "$repo" in
215                 ./*|../*)
216                         url=$(resolve_relative_url "$repo") || exit
217                     ;;
218                 *)
219                         url="$repo"
220                         ;;
221                 esac
222                 git config submodule."$path".url "$url"
223         else
225                 module_clone "$path" "$realrepo" "$reference" || exit
226                 (
227                         clear_local_git_env
228                         cd "$path" &&
229                         # ash fails to wordsplit ${branch:+-b "$branch"...}
230                         case "$branch" in
231                         '') git checkout -f -q ;;
232                         ?*) git checkout -f -q -b "$branch" "origin/$branch" ;;
233                         esac
234                 ) || die "Unable to checkout submodule '$path'"
235         fi
237         git add "$path" ||
238         die "Failed to add submodule '$path'"
240         git config -f .gitmodules submodule."$path".path "$path" &&
241         git config -f .gitmodules submodule."$path".url "$repo" &&
242         git add .gitmodules ||
243         die "Failed to register submodule '$path'"
247 # Execute an arbitrary command sequence in each checked out
248 # submodule
250 # $@ = command to execute
252 cmd_foreach()
254         # parse $args after "submodule ... foreach".
255         while test $# -ne 0
256         do
257                 case "$1" in
258                 -q|--quiet)
259                         GIT_QUIET=1
260                         ;;
261                 --recursive)
262                         recursive=1
263                         ;;
264                 -*)
265                         usage
266                         ;;
267                 *)
268                         break
269                         ;;
270                 esac
271                 shift
272         done
274         module_list |
275         while read mode sha1 stage path
276         do
277                 if test -e "$path"/.git
278                 then
279                         say "Entering '$prefix$path'"
280                         name=$(module_name "$path")
281                         (
282                                 prefix="$prefix$path/"
283                                 clear_local_git_env
284                                 cd "$path" &&
285                                 eval "$@" &&
286                                 if test -n "$recursive"
287                                 then
288                                         cmd_foreach "--recursive" "$@"
289                                 fi
290                         ) ||
291                         die "Stopping at '$path'; script returned non-zero status."
292                 fi
293         done
297 # Register submodules in .git/config
299 # $@ = requested paths (default to all)
301 cmd_init()
303         # parse $args after "submodule ... init".
304         while test $# -ne 0
305         do
306                 case "$1" in
307                 -q|--quiet)
308                         GIT_QUIET=1
309                         ;;
310                 --)
311                         shift
312                         break
313                         ;;
314                 -*)
315                         usage
316                         ;;
317                 *)
318                         break
319                         ;;
320                 esac
321                 shift
322         done
324         module_list "$@" |
325         while read mode sha1 stage path
326         do
327                 # Skip already registered paths
328                 name=$(module_name "$path") || exit
329                 url=$(git config submodule."$name".url)
330                 test -z "$url" || continue
332                 url=$(git config -f .gitmodules submodule."$name".url)
333                 test -z "$url" &&
334                 die "No url found for submodule path '$path' in .gitmodules"
336                 # Possibly a url relative to parent
337                 case "$url" in
338                 ./*|../*)
339                         url=$(resolve_relative_url "$url") || exit
340                         ;;
341                 esac
343                 git config submodule."$name".url "$url" ||
344                 die "Failed to register url for submodule path '$path'"
346                 upd="$(git config -f .gitmodules submodule."$name".update)"
347                 test -z "$upd" ||
348                 git config submodule."$name".update "$upd" ||
349                 die "Failed to register update mode for submodule path '$path'"
351                 say "Submodule '$name' ($url) registered for path '$path'"
352         done
356 # Update each submodule path to correct revision, using clone and checkout as needed
358 # $@ = requested paths (default to all)
360 cmd_update()
362         # parse $args after "submodule ... update".
363         orig_args="$@"
364         while test $# -ne 0
365         do
366                 case "$1" in
367                 -q|--quiet)
368                         shift
369                         GIT_QUIET=1
370                         ;;
371                 -i|--init)
372                         init=1
373                         shift
374                         ;;
375                 -N|--no-fetch)
376                         shift
377                         nofetch=1
378                         ;;
379                 -r|--rebase)
380                         shift
381                         update="rebase"
382                         ;;
383                 --reference)
384                         case "$2" in '') usage ;; esac
385                         reference="--reference=$2"
386                         shift 2
387                         ;;
388                 --reference=*)
389                         reference="$1"
390                         shift
391                         ;;
392                 -m|--merge)
393                         shift
394                         update="merge"
395                         ;;
396                 --recursive)
397                         shift
398                         recursive=1
399                         ;;
400                 --)
401                         shift
402                         break
403                         ;;
404                 -*)
405                         usage
406                         ;;
407                 *)
408                         break
409                         ;;
410                 esac
411         done
413         if test -n "$init"
414         then
415                 cmd_init "--" "$@" || return
416         fi
418         module_list "$@" |
419         while read mode sha1 stage path
420         do
421                 name=$(module_name "$path") || exit
422                 url=$(git config submodule."$name".url)
423                 update_module=$(git config submodule."$name".update)
424                 if test -z "$url"
425                 then
426                         # Only mention uninitialized submodules when its
427                         # path have been specified
428                         test "$#" != "0" &&
429                         say "Submodule path '$path' not initialized" &&
430                         say "Maybe you want to use 'update --init'?"
431                         continue
432                 fi
434                 if ! test -d "$path"/.git -o -f "$path"/.git
435                 then
436                         module_clone "$path" "$url" "$reference"|| exit
437                         subsha1=
438                 else
439                         subsha1=$(clear_local_git_env; cd "$path" &&
440                                 git rev-parse --verify HEAD) ||
441                         die "Unable to find current revision in submodule path '$path'"
442                 fi
444                 if ! test -z "$update"
445                 then
446                         update_module=$update
447                 fi
449                 if test "$subsha1" != "$sha1"
450                 then
451                         force=
452                         if test -z "$subsha1"
453                         then
454                                 force="-f"
455                         fi
457                         if test -z "$nofetch"
458                         then
459                                 (clear_local_git_env; cd "$path" &&
460                                         git-fetch) ||
461                                 die "Unable to fetch in submodule path '$path'"
462                         fi
464                         case "$update_module" in
465                         rebase)
466                                 command="git rebase"
467                                 action="rebase"
468                                 msg="rebased onto"
469                                 ;;
470                         merge)
471                                 command="git merge"
472                                 action="merge"
473                                 msg="merged in"
474                                 ;;
475                         *)
476                                 command="git checkout $force -q"
477                                 action="checkout"
478                                 msg="checked out"
479                                 ;;
480                         esac
482                         (clear_local_git_env; cd "$path" && $command "$sha1") ||
483                         die "Unable to $action '$sha1' in submodule path '$path'"
484                         say "Submodule path '$path': $msg '$sha1'"
485                 fi
487                 if test -n "$recursive"
488                 then
489                         (clear_local_git_env; cd "$path" && cmd_update $orig_args) ||
490                         die "Failed to recurse into submodule path '$path'"
491                 fi
492         done
495 set_name_rev () {
496         revname=$( (
497                 clear_local_git_env
498                 cd "$1" && {
499                         git describe "$2" 2>/dev/null ||
500                         git describe --tags "$2" 2>/dev/null ||
501                         git describe --contains "$2" 2>/dev/null ||
502                         git describe --all --always "$2"
503                 }
504         ) )
505         test -z "$revname" || revname=" ($revname)"
508 # Show commit summary for submodules in index or working tree
510 # If '--cached' is given, show summary between index and given commit,
511 # or between working tree and given commit
513 # $@ = [commit (default 'HEAD'),] requested paths (default all)
515 cmd_summary() {
516         summary_limit=-1
517         for_status=
518         diff_cmd=diff-index
520         # parse $args after "submodule ... summary".
521         while test $# -ne 0
522         do
523                 case "$1" in
524                 --cached)
525                         cached="$1"
526                         ;;
527                 --files)
528                         files="$1"
529                         ;;
530                 --for-status)
531                         for_status="$1"
532                         ;;
533                 -n|--summary-limit)
534                         if summary_limit=$(($2 + 0)) 2>/dev/null && test "$summary_limit" = "$2"
535                         then
536                                 :
537                         else
538                                 usage
539                         fi
540                         shift
541                         ;;
542                 --)
543                         shift
544                         break
545                         ;;
546                 -*)
547                         usage
548                         ;;
549                 *)
550                         break
551                         ;;
552                 esac
553                 shift
554         done
556         test $summary_limit = 0 && return
558         if rev=$(git rev-parse -q --verify --default HEAD ${1+"$1"})
559         then
560                 head=$rev
561                 test $# = 0 || shift
562         elif test -z "$1" -o "$1" = "HEAD"
563         then
564                 # before the first commit: compare with an empty tree
565                 head=$(git hash-object -w -t tree --stdin </dev/null)
566                 test -z "$1" || shift
567         else
568                 head="HEAD"
569         fi
571         if [ -n "$files" ]
572         then
573                 test -n "$cached" &&
574                 die "--cached cannot be used with --files"
575                 diff_cmd=diff-files
576                 head=
577         fi
579         cd_to_toplevel
580         # Get modified modules cared by user
581         modules=$(git $diff_cmd $cached --raw $head -- "$@" |
582                 sane_egrep '^:([0-7]* )?160000' |
583                 while read mod_src mod_dst sha1_src sha1_dst status name
584                 do
585                         # Always show modules deleted or type-changed (blob<->module)
586                         test $status = D -o $status = T && echo "$name" && continue
587                         # Also show added or modified modules which are checked out
588                         GIT_DIR="$name/.git" git-rev-parse --git-dir >/dev/null 2>&1 &&
589                         echo "$name"
590                 done
591         )
593         test -z "$modules" && return
595         git $diff_cmd $cached --raw $head -- $modules |
596         sane_egrep '^:([0-7]* )?160000' |
597         cut -c2- |
598         while read mod_src mod_dst sha1_src sha1_dst status name
599         do
600                 if test -z "$cached" &&
601                         test $sha1_dst = 0000000000000000000000000000000000000000
602                 then
603                         case "$mod_dst" in
604                         160000)
605                                 sha1_dst=$(GIT_DIR="$name/.git" git rev-parse HEAD)
606                                 ;;
607                         100644 | 100755 | 120000)
608                                 sha1_dst=$(git hash-object $name)
609                                 ;;
610                         000000)
611                                 ;; # removed
612                         *)
613                                 # unexpected type
614                                 echo >&2 "unexpected mode $mod_dst"
615                                 continue ;;
616                         esac
617                 fi
618                 missing_src=
619                 missing_dst=
621                 test $mod_src = 160000 &&
622                 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_src^0 >/dev/null &&
623                 missing_src=t
625                 test $mod_dst = 160000 &&
626                 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_dst^0 >/dev/null &&
627                 missing_dst=t
629                 total_commits=
630                 case "$missing_src,$missing_dst" in
631                 t,)
632                         errmsg="  Warn: $name doesn't contain commit $sha1_src"
633                         ;;
634                 ,t)
635                         errmsg="  Warn: $name doesn't contain commit $sha1_dst"
636                         ;;
637                 t,t)
638                         errmsg="  Warn: $name doesn't contain commits $sha1_src and $sha1_dst"
639                         ;;
640                 *)
641                         errmsg=
642                         total_commits=$(
643                         if test $mod_src = 160000 -a $mod_dst = 160000
644                         then
645                                 range="$sha1_src...$sha1_dst"
646                         elif test $mod_src = 160000
647                         then
648                                 range=$sha1_src
649                         else
650                                 range=$sha1_dst
651                         fi
652                         GIT_DIR="$name/.git" \
653                         git log --pretty=oneline --first-parent $range | wc -l
654                         )
655                         total_commits=" ($(($total_commits + 0)))"
656                         ;;
657                 esac
659                 sha1_abbr_src=$(echo $sha1_src | cut -c1-7)
660                 sha1_abbr_dst=$(echo $sha1_dst | cut -c1-7)
661                 if test $status = T
662                 then
663                         if test $mod_dst = 160000
664                         then
665                                 echo "* $name $sha1_abbr_src(blob)->$sha1_abbr_dst(submodule)$total_commits:"
666                         else
667                                 echo "* $name $sha1_abbr_src(submodule)->$sha1_abbr_dst(blob)$total_commits:"
668                         fi
669                 else
670                         echo "* $name $sha1_abbr_src...$sha1_abbr_dst$total_commits:"
671                 fi
672                 if test -n "$errmsg"
673                 then
674                         # Don't give error msg for modification whose dst is not submodule
675                         # i.e. deleted or changed to blob
676                         test $mod_dst = 160000 && echo "$errmsg"
677                 else
678                         if test $mod_src = 160000 -a $mod_dst = 160000
679                         then
680                                 limit=
681                                 test $summary_limit -gt 0 && limit="-$summary_limit"
682                                 GIT_DIR="$name/.git" \
683                                 git log $limit --pretty='format:  %m %s' \
684                                 --first-parent $sha1_src...$sha1_dst
685                         elif test $mod_dst = 160000
686                         then
687                                 GIT_DIR="$name/.git" \
688                                 git log --pretty='format:  > %s' -1 $sha1_dst
689                         else
690                                 GIT_DIR="$name/.git" \
691                                 git log --pretty='format:  < %s' -1 $sha1_src
692                         fi
693                         echo
694                 fi
695                 echo
696         done |
697         if test -n "$for_status"; then
698                 if [ -n "$files" ]; then
699                         echo "# Submodules changed but not updated:"
700                 else
701                         echo "# Submodule changes to be committed:"
702                 fi
703                 echo "#"
704                 sed -e 's|^|# |' -e 's|^# $|#|'
705         else
706                 cat
707         fi
710 # List all submodules, prefixed with:
711 #  - submodule not initialized
712 #  + different revision checked out
714 # If --cached was specified the revision in the index will be printed
715 # instead of the currently checked out revision.
717 # $@ = requested paths (default to all)
719 cmd_status()
721         # parse $args after "submodule ... status".
722         orig_args="$@"
723         while test $# -ne 0
724         do
725                 case "$1" in
726                 -q|--quiet)
727                         GIT_QUIET=1
728                         ;;
729                 --cached)
730                         cached=1
731                         ;;
732                 --recursive)
733                         recursive=1
734                         ;;
735                 --)
736                         shift
737                         break
738                         ;;
739                 -*)
740                         usage
741                         ;;
742                 *)
743                         break
744                         ;;
745                 esac
746                 shift
747         done
749         module_list "$@" |
750         while read mode sha1 stage path
751         do
752                 name=$(module_name "$path") || exit
753                 url=$(git config submodule."$name".url)
754                 displaypath="$prefix$path"
755                 if test -z "$url" || ! test -d "$path"/.git -o -f "$path"/.git
756                 then
757                         say "-$sha1 $displaypath"
758                         continue;
759                 fi
760                 set_name_rev "$path" "$sha1"
761                 if git diff-files --quiet -- "$path"
762                 then
763                         say " $sha1 $displaypath$revname"
764                 else
765                         if test -z "$cached"
766                         then
767                                 sha1=$(clear_local_git_env; cd "$path" && git rev-parse --verify HEAD)
768                                 set_name_rev "$path" "$sha1"
769                         fi
770                         say "+$sha1 $displaypath$revname"
771                 fi
773                 if test -n "$recursive"
774                 then
775                         (
776                                 prefix="$displaypath/"
777                                 clear_local_git_env
778                                 cd "$path" &&
779                                 cmd_status $orig_args
780                         ) ||
781                         die "Failed to recurse into submodule path '$path'"
782                 fi
783         done
786 # Sync remote urls for submodules
787 # This makes the value for remote.$remote.url match the value
788 # specified in .gitmodules.
790 cmd_sync()
792         while test $# -ne 0
793         do
794                 case "$1" in
795                 -q|--quiet)
796                         GIT_QUIET=1
797                         shift
798                         ;;
799                 --)
800                         shift
801                         break
802                         ;;
803                 -*)
804                         usage
805                         ;;
806                 *)
807                         break
808                         ;;
809                 esac
810         done
811         cd_to_toplevel
812         module_list "$@" |
813         while read mode sha1 stage path
814         do
815                 name=$(module_name "$path")
816                 url=$(git config -f .gitmodules --get submodule."$name".url)
818                 # Possibly a url relative to parent
819                 case "$url" in
820                 ./*|../*)
821                         url=$(resolve_relative_url "$url") || exit
822                         ;;
823                 esac
825                 if test -e "$path"/.git
826                 then
827                 (
828                         clear_local_git_env
829                         cd "$path"
830                         remote=$(get_default_remote)
831                         say "Synchronizing submodule url for '$name'"
832                         git config remote."$remote".url "$url"
833                 )
834                 fi
835         done
838 # This loop parses the command line arguments to find the
839 # subcommand name to dispatch.  Parsing of the subcommand specific
840 # options are primarily done by the subcommand implementations.
841 # Subcommand specific options such as --branch and --cached are
842 # parsed here as well, for backward compatibility.
844 while test $# != 0 && test -z "$command"
845 do
846         case "$1" in
847         add | foreach | init | update | status | summary | sync)
848                 command=$1
849                 ;;
850         -q|--quiet)
851                 GIT_QUIET=1
852                 ;;
853         -b|--branch)
854                 case "$2" in
855                 '')
856                         usage
857                         ;;
858                 esac
859                 branch="$2"; shift
860                 ;;
861         --cached)
862                 cached="$1"
863                 ;;
864         --)
865                 break
866                 ;;
867         -*)
868                 usage
869                 ;;
870         *)
871                 break
872                 ;;
873         esac
874         shift
875 done
877 # No command word defaults to "status"
878 test -n "$command" || command=status
880 # "-b branch" is accepted only by "add"
881 if test -n "$branch" && test "$command" != add
882 then
883         usage
884 fi
886 # "--cached" is accepted only by "status" and "summary"
887 if test -n "$cached" && test "$command" != status -a "$command" != summary
888 then
889         usage
890 fi
892 "cmd_$command" "$@"