Merge git://repo.or.cz/git-gui
[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] [add <repo> [-b branch]|status|init|update] [--] [<path>...]'
8 OPTIONS_SPEC=
9 . git-sh-setup
10 require_work_tree
11
12 command=
13 branch=
14 quiet=
15 cached=
16
17 #
18 # print stuff on stdout unless -q was specified
19 #
20 say()
21 {
22         if test -z "$quiet"
23         then
24                 echo "$@"
25         fi
26 }
27
28 # NEEDSWORK: identical function exists in get_repo_base in clone.sh
29 get_repo_base() {
30         (
31                 cd "`/bin/pwd`" &&
32                 cd "$1" || cd "$1.git" &&
33                 {
34                         cd .git
35                         pwd
36                 }
37         ) 2>/dev/null
38 }
39
40 # Resolve relative url by appending to parent's url
41 resolve_relative_url ()
42 {
43         branch="$(git symbolic-ref HEAD 2>/dev/null)"
44         remote="$(git config branch.${branch#refs/heads/}.remote)"
45         remote="${remote:-origin}"
46         remoteurl="$(git config remote.$remote.url)" ||
47                 die "remote ($remote) does not have a url in .git/config"
48         url="$1"
49         while test -n "$url"
50         do
51                 case "$url" in
52                 ../*)
53                         url="${url#../}"
54                         remoteurl="${remoteurl%/*}"
55                         ;;
56                 ./*)
57                         url="${url#./}"
58                         ;;
59                 *)
60                         break;;
61                 esac
62         done
63         echo "$remoteurl/$url"
64 }
65
66 #
67 # Map submodule path to submodule name
68 #
69 # $1 = path
70 #
71 module_name()
72 {
73         # Do we have "submodule.<something>.path = $1" defined in .gitmodules file?
74         re=$(printf '%s' "$1" | sed -e 's/[].[^$\\*]/\\&/g')
75         name=$( GIT_CONFIG=.gitmodules \
76                 git config --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
96         # If there already is a directory at the submodule path,
97         # expect it to be empty (since that is the default checkout
98         # action) and try to remove it.
99         # Note: if $path is a symlink to a directory the test will
100         # succeed but the rmdir will fail. We might want to fix this.
101         if test -d "$path"
102         then
103                 rmdir "$path" 2>/dev/null ||
104                 die "Directory '$path' exist, but is neither empty nor a git repository"
105         fi
106
107         test -e "$path" &&
108         die "A file already exist at path '$path'"
109
110         git-clone -n "$url" "$path" ||
111         die "Clone of '$url' into submodule path '$path' failed"
112 }
113
114 #
115 # Add a new submodule to the working tree, .gitmodules and the index
116 #
117 # $@ = repo [path]
118 #
119 # optional branch is stored in global branch variable
120 #
121 cmd_add()
122 {
123         # parse $args after "submodule ... add".
124         while test $# -ne 0
125         do
126                 case "$1" in
127                 -b | --branch)
128                         case "$2" in '') usage ;; esac
129                         branch=$2
130                         shift
131                         ;;
132                 -q|--quiet)
133                         quiet=1
134                         ;;
135                 --)
136                         shift
137                         break
138                         ;;
139                 -*)
140                         usage
141                         ;;
142                 *)
143                         break
144                         ;;
145                 esac
146                 shift
147         done
148
149         repo=$1
150         path=$2
151
152         if test -z "$repo"; then
153                 usage
154         fi
155
156         case "$repo" in
157         ./*|../*)
158                 # dereference source url relative to parent's url
159                 realrepo="$(resolve_relative_url $repo)" ;;
160         *)
161                 # Turn the source into an absolute path if
162                 # it is local
163                 if base=$(get_repo_base "$repo"); then
164                         repo="$base"
165                 fi
166                 realrepo=$repo
167                 ;;
168         esac
169
170         # Guess path from repo if not specified or strip trailing slashes
171         if test -z "$path"; then
172                 path=$(echo "$repo" | sed -e 's|/*$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
173         else
174                 path=$(echo "$path" | sed -e 's|/*$||')
175         fi
176
177         test -e "$path" &&
178         die "'$path' already exists"
179
180         git ls-files --error-unmatch "$path" > /dev/null 2>&1 &&
181         die "'$path' already exists in the index"
182
183         module_clone "$path" "$realrepo" || exit
184         (unset GIT_DIR; cd "$path" && git checkout -q ${branch:+-b "$branch" "origin/$branch"}) ||
185         die "Unable to checkout submodule '$path'"
186         git add "$path" ||
187         die "Failed to add submodule '$path'"
188
189         GIT_CONFIG=.gitmodules git config submodule."$path".path "$path" &&
190         GIT_CONFIG=.gitmodules git config submodule."$path".url "$repo" &&
191         git add .gitmodules ||
192         die "Failed to register submodule '$path'"
193 }
194
195 #
196 # Register submodules in .git/config
197 #
198 # $@ = requested paths (default to all)
199 #
200 cmd_init()
201 {
202         # parse $args after "submodule ... init".
203         while test $# -ne 0
204         do
205                 case "$1" in
206                 -q|--quiet)
207                         quiet=1
208                         ;;
209                 --)
210                         shift
211                         break
212                         ;;
213                 -*)
214                         usage
215                         ;;
216                 *)
217                         break
218                         ;;
219                 esac
220                 shift
221         done
222
223         git ls-files --stage -- "$@" | grep -e '^160000 ' |
224         while read mode sha1 stage path
225         do
226                 # Skip already registered paths
227                 name=$(module_name "$path") || exit
228                 url=$(git config submodule."$name".url)
229                 test -z "$url" || continue
230
231                 url=$(GIT_CONFIG=.gitmodules git config submodule."$name".url)
232                 test -z "$url" &&
233                 die "No url found for submodule path '$path' in .gitmodules"
234
235                 # Possibly a url relative to parent
236                 case "$url" in
237                 ./*|../*)
238                         url="$(resolve_relative_url "$url")"
239                         ;;
240                 esac
241
242                 git config submodule."$name".url "$url" ||
243                 die "Failed to register url for submodule path '$path'"
244
245                 say "Submodule '$name' ($url) registered for path '$path'"
246         done
247 }
248
249 #
250 # Update each submodule path to correct revision, using clone and checkout as needed
251 #
252 # $@ = requested paths (default to all)
253 #
254 cmd_update()
255 {
256         # parse $args after "submodule ... update".
257         while test $# -ne 0
258         do
259                 case "$1" in
260                 -q|--quiet)
261                         quiet=1
262                         ;;
263                 --)
264                         shift
265                         break
266                         ;;
267                 -*)
268                         usage
269                         ;;
270                 *)
271                         break
272                         ;;
273                 esac
274                 shift
275         done
276
277         git ls-files --stage -- "$@" | grep -e '^160000 ' |
278         while read mode sha1 stage path
279         do
280                 name=$(module_name "$path") || exit
281                 url=$(git config submodule."$name".url)
282                 if test -z "$url"
283                 then
284                         # Only mention uninitialized submodules when its
285                         # path have been specified
286                         test "$#" != "0" &&
287                         say "Submodule path '$path' not initialized"
288                         continue
289                 fi
290
291                 if ! test -d "$path"/.git
292                 then
293                         module_clone "$path" "$url" || exit
294                         subsha1=
295                 else
296                         subsha1=$(unset GIT_DIR; cd "$path" &&
297                                 git rev-parse --verify HEAD) ||
298                         die "Unable to find current revision in submodule path '$path'"
299                 fi
300
301                 if test "$subsha1" != "$sha1"
302                 then
303                         (unset GIT_DIR; cd "$path" && git-fetch &&
304                                 git-checkout -q "$sha1") ||
305                         die "Unable to checkout '$sha1' in submodule path '$path'"
306
307                         say "Submodule path '$path': checked out '$sha1'"
308                 fi
309         done
310 }
311
312 set_name_rev () {
313         revname=$( (
314                 unset GIT_DIR
315                 cd "$1" && {
316                         git describe "$2" 2>/dev/null ||
317                         git describe --tags "$2" 2>/dev/null ||
318                         git describe --contains --tags "$2"
319                 }
320         ) )
321         test -z "$revname" || revname=" ($revname)"
322 }
323
324 #
325 # List all submodules, prefixed with:
326 #  - submodule not initialized
327 #  + different revision checked out
328 #
329 # If --cached was specified the revision in the index will be printed
330 # instead of the currently checked out revision.
331 #
332 # $@ = requested paths (default to all)
333 #
334 cmd_status()
335 {
336         # parse $args after "submodule ... status".
337         while test $# -ne 0
338         do
339                 case "$1" in
340                 -q|--quiet)
341                         quiet=1
342                         ;;
343                 --cached)
344                         cached=1
345                         ;;
346                 --)
347                         shift
348                         break
349                         ;;
350                 -*)
351                         usage
352                         ;;
353                 *)
354                         break
355                         ;;
356                 esac
357                 shift
358         done
359
360         git ls-files --stage -- "$@" | grep -e '^160000 ' |
361         while read mode sha1 stage path
362         do
363                 name=$(module_name "$path") || exit
364                 url=$(git config submodule."$name".url)
365                 if test -z "url" || ! test -d "$path"/.git
366                 then
367                         say "-$sha1 $path"
368                         continue;
369                 fi
370                 set_name_rev "$path" "$sha1"
371                 if git diff-files --quiet -- "$path"
372                 then
373                         say " $sha1 $path$revname"
374                 else
375                         if test -z "$cached"
376                         then
377                                 sha1=$(unset GIT_DIR; cd "$path" && git rev-parse --verify HEAD)
378                                 set_name_rev "$path" "$sha1"
379                         fi
380                         say "+$sha1 $path$revname"
381                 fi
382         done
383 }
384
385 # This loop parses the command line arguments to find the
386 # subcommand name to dispatch.  Parsing of the subcommand specific
387 # options are primarily done by the subcommand implementations.
388 # Subcommand specific options such as --branch and --cached are
389 # parsed here as well, for backward compatibility.
390
391 while test $# != 0 && test -z "$command"
392 do
393         case "$1" in
394         add | init | update | status)
395                 command=$1
396                 ;;
397         -q|--quiet)
398                 quiet=1
399                 ;;
400         -b|--branch)
401                 case "$2" in
402                 '')
403                         usage
404                         ;;
405                 esac
406                 branch="$2"; shift
407                 ;;
408         --cached)
409                 cached=1
410                 ;;
411         --)
412                 break
413                 ;;
414         -*)
415                 usage
416                 ;;
417         *)
418                 break
419                 ;;
420         esac
421         shift
422 done
423
424 # No command word defaults to "status"
425 test -n "$command" || command=status
426
427 # "-b branch" is accepted only by "add"
428 if test -n "$branch" && test "$command" != add
429 then
430         usage
431 fi
432
433 # "--cached" is accepted only by "status"
434 if test -n "$cached" && test "$command" != status
435 then
436         usage
437 fi
438
439 "cmd_$command" "$@"