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