]>
Commit | Line | Data |
---|---|---|
1 | git-submodule(1) | |
2 | ================ | |
3 | ||
4 | NAME | |
5 | ---- | |
6 | git-submodule - Initialize, update or inspect submodules | |
7 | ||
8 | ||
9 | SYNOPSIS | |
10 | -------- | |
11 | [verse] | |
12 | 'git submodule' [--quiet] add [<options>] [--] <repository> [<path>] | |
13 | 'git submodule' [--quiet] status [--cached] [--recursive] [--] [<path>...] | |
14 | 'git submodule' [--quiet] init [--] [<path>...] | |
15 | 'git submodule' [--quiet] deinit [-f|--force] (--all|[--] <path>...) | |
16 | 'git submodule' [--quiet] update [<options>] [--] [<path>...] | |
17 | 'git submodule' [--quiet] summary [<options>] [--] [<path>...] | |
18 | 'git submodule' [--quiet] foreach [--recursive] <command> | |
19 | 'git submodule' [--quiet] sync [--recursive] [--] [<path>...] | |
20 | 'git submodule' [--quiet] absorbgitdirs [--] [<path>...] | |
21 | ||
22 | ||
23 | DESCRIPTION | |
24 | ----------- | |
25 | Inspects, updates and manages submodules. | |
26 | ||
27 | A submodule allows you to keep another Git repository in a subdirectory | |
28 | of your repository. The other repository has its own history, which does not | |
29 | interfere with the history of the current repository. This can be used to | |
30 | have external dependencies such as third party libraries for example. | |
31 | ||
32 | When cloning or pulling a repository containing submodules however, | |
33 | these will not be checked out by default; the 'init' and 'update' | |
34 | subcommands will maintain submodules checked out and at | |
35 | appropriate revision in your working tree. | |
36 | ||
37 | Submodules are composed from a so-called `gitlink` tree entry | |
38 | in the main repository that refers to a particular commit object | |
39 | within the inner repository that is completely separate. | |
40 | A record in the `.gitmodules` (see linkgit:gitmodules[5]) file at the | |
41 | root of the source tree assigns a logical name to the submodule and | |
42 | describes the default URL the submodule shall be cloned from. | |
43 | The logical name can be used for overriding this URL within your | |
44 | local repository configuration (see 'submodule init'). | |
45 | ||
46 | Submodules are not to be confused with remotes, which are other | |
47 | repositories of the same project; submodules are meant for | |
48 | different projects you would like to make part of your source tree, | |
49 | while the history of the two projects still stays completely | |
50 | independent and you cannot modify the contents of the submodule | |
51 | from within the main project. | |
52 | If you want to merge the project histories and want to treat the | |
53 | aggregated whole as a single project from then on, you may want to | |
54 | add a remote for the other project and use the 'subtree' merge strategy, | |
55 | instead of treating the other project as a submodule. Directories | |
56 | that come from both projects can be cloned and checked out as a whole | |
57 | if you choose to go that route. | |
58 | ||
59 | COMMANDS | |
60 | -------- | |
61 | add [-b <branch>] [-f|--force] [--name <name>] [--reference <repository>] [--depth <depth>] [--] <repository> [<path>]:: | |
62 | Add the given repository as a submodule at the given path | |
63 | to the changeset to be committed next to the current | |
64 | project: the current project is termed the "superproject". | |
65 | + | |
66 | This requires at least one argument: <repository>. The optional | |
67 | argument <path> is the relative location for the cloned submodule | |
68 | to exist in the superproject. If <path> is not given, the | |
69 | "humanish" part of the source repository is used ("repo" for | |
70 | "/path/to/repo.git" and "foo" for "host.xz:foo/.git"). | |
71 | The <path> is also used as the submodule's logical name in its | |
72 | configuration entries unless `--name` is used to specify a logical name. | |
73 | + | |
74 | <repository> is the URL of the new submodule's origin repository. | |
75 | This may be either an absolute URL, or (if it begins with ./ | |
76 | or ../), the location relative to the superproject's origin | |
77 | repository (Please note that to specify a repository 'foo.git' | |
78 | which is located right next to a superproject 'bar.git', you'll | |
79 | have to use '../foo.git' instead of './foo.git' - as one might expect | |
80 | when following the rules for relative URLs - because the evaluation | |
81 | of relative URLs in Git is identical to that of relative directories). | |
82 | If the superproject doesn't have an origin configured | |
83 | the superproject is its own authoritative upstream and the current | |
84 | working directory is used instead. | |
85 | + | |
86 | <path> is the relative location for the cloned submodule to | |
87 | exist in the superproject. If <path> does not exist, then the | |
88 | submodule is created by cloning from the named URL. If <path> does | |
89 | exist and is already a valid Git repository, then this is added | |
90 | to the changeset without cloning. This second form is provided | |
91 | to ease creating a new submodule from scratch, and presumes | |
92 | the user will later push the submodule to the given URL. | |
93 | + | |
94 | In either case, the given URL is recorded into .gitmodules for | |
95 | use by subsequent users cloning the superproject. If the URL is | |
96 | given relative to the superproject's repository, the presumption | |
97 | is the superproject and submodule repositories will be kept | |
98 | together in the same relative location, and only the | |
99 | superproject's URL needs to be provided: git-submodule will correctly | |
100 | locate the submodule using the relative URL in .gitmodules. | |
101 | ||
102 | status [--cached] [--recursive] [--] [<path>...]:: | |
103 | Show the status of the submodules. This will print the SHA-1 of the | |
104 | currently checked out commit for each submodule, along with the | |
105 | submodule path and the output of 'git describe' for the | |
106 | SHA-1. Each SHA-1 will be prefixed with `-` if the submodule is not | |
107 | initialized, `+` if the currently checked out submodule commit | |
108 | does not match the SHA-1 found in the index of the containing | |
109 | repository and `U` if the submodule has merge conflicts. | |
110 | + | |
111 | If `--recursive` is specified, this command will recurse into nested | |
112 | submodules, and show their status as well. | |
113 | + | |
114 | If you are only interested in changes of the currently initialized | |
115 | submodules with respect to the commit recorded in the index or the HEAD, | |
116 | linkgit:git-status[1] and linkgit:git-diff[1] will provide that information | |
117 | too (and can also report changes to a submodule's work tree). | |
118 | ||
119 | init [--] [<path>...]:: | |
120 | Initialize the submodules recorded in the index (which were | |
121 | added and committed elsewhere) by copying submodule | |
122 | names and urls from .gitmodules to .git/config. | |
123 | Optional <path> arguments limit which submodules will be initialized. | |
124 | It will also copy the value of `submodule.$name.update` into | |
125 | .git/config. | |
126 | The key used in .git/config is `submodule.$name.url`. | |
127 | This command does not alter existing information in .git/config. | |
128 | You can then customize the submodule clone URLs in .git/config | |
129 | for your local setup and proceed to `git submodule update`; | |
130 | you can also just use `git submodule update --init` without | |
131 | the explicit 'init' step if you do not intend to customize | |
132 | any submodule locations. | |
133 | ||
134 | deinit [-f|--force] (--all|[--] <path>...):: | |
135 | Unregister the given submodules, i.e. remove the whole | |
136 | `submodule.$name` section from .git/config together with their work | |
137 | tree. Further calls to `git submodule update`, `git submodule foreach` | |
138 | and `git submodule sync` will skip any unregistered submodules until | |
139 | they are initialized again, so use this command if you don't want to | |
140 | have a local checkout of the submodule in your working tree anymore. If | |
141 | you really want to remove a submodule from the repository and commit | |
142 | that use linkgit:git-rm[1] instead. | |
143 | + | |
144 | When the command is run without pathspec, it errors out, | |
145 | instead of deinit-ing everything, to prevent mistakes. | |
146 | + | |
147 | If `--force` is specified, the submodule's working tree will | |
148 | be removed even if it contains local modifications. | |
149 | ||
150 | update [--init] [--remote] [-N|--no-fetch] [--[no-]recommend-shallow] [-f|--force] [--checkout|--rebase|--merge] [--reference <repository>] [--depth <depth>] [--recursive] [--jobs <n>] [--] [<path>...]:: | |
151 | + | |
152 | -- | |
153 | Update the registered submodules to match what the superproject | |
154 | expects by cloning missing submodules and updating the working tree of | |
155 | the submodules. The "updating" can be done in several ways depending | |
156 | on command line options and the value of `submodule.<name>.update` | |
157 | configuration variable. The command line option takes precedence over | |
158 | the configuration variable. if neither is given, a checkout is performed. | |
159 | update procedures supported both from the command line as well as setting | |
160 | `submodule.<name>.update`: | |
161 | ||
162 | checkout;; the commit recorded in the superproject will be | |
163 | checked out in the submodule on a detached HEAD. | |
164 | + | |
165 | If `--force` is specified, the submodule will be checked out (using | |
166 | `git checkout --force` if appropriate), even if the commit specified | |
167 | in the index of the containing repository already matches the commit | |
168 | checked out in the submodule. | |
169 | ||
170 | rebase;; the current branch of the submodule will be rebased | |
171 | onto the commit recorded in the superproject. | |
172 | ||
173 | merge;; the commit recorded in the superproject will be merged | |
174 | into the current branch in the submodule. | |
175 | ||
176 | The following procedures are only available via the `submodule.<name>.update` | |
177 | configuration variable: | |
178 | ||
179 | custom command;; arbitrary shell command that takes a single | |
180 | argument (the sha1 of the commit recorded in the | |
181 | superproject) is executed. When `submodule.<name>.update` | |
182 | is set to '!command', the remainder after the exclamation mark | |
183 | is the custom command. | |
184 | ||
185 | none;; the submodule is not updated. | |
186 | ||
187 | If the submodule is not yet initialized, and you just want to use the | |
188 | setting as stored in .gitmodules, you can automatically initialize the | |
189 | submodule with the `--init` option. | |
190 | ||
191 | If `--recursive` is specified, this command will recurse into the | |
192 | registered submodules, and update any nested submodules within. | |
193 | -- | |
194 | summary [--cached|--files] [(-n|--summary-limit) <n>] [commit] [--] [<path>...]:: | |
195 | Show commit summary between the given commit (defaults to HEAD) and | |
196 | working tree/index. For a submodule in question, a series of commits | |
197 | in the submodule between the given super project commit and the | |
198 | index or working tree (switched by `--cached`) are shown. If the option | |
199 | `--files` is given, show the series of commits in the submodule between | |
200 | the index of the super project and the working tree of the submodule | |
201 | (this option doesn't allow to use the `--cached` option or to provide an | |
202 | explicit commit). | |
203 | + | |
204 | Using the `--submodule=log` option with linkgit:git-diff[1] will provide that | |
205 | information too. | |
206 | ||
207 | foreach [--recursive] <command>:: | |
208 | Evaluates an arbitrary shell command in each checked out submodule. | |
209 | The command has access to the variables $name, $path, $sha1 and | |
210 | $toplevel: | |
211 | $name is the name of the relevant submodule section in .gitmodules, | |
212 | $path is the name of the submodule directory relative to the | |
213 | superproject, $sha1 is the commit as recorded in the superproject, | |
214 | and $toplevel is the absolute path to the top-level of the superproject. | |
215 | Any submodules defined in the superproject but not checked out are | |
216 | ignored by this command. Unless given `--quiet`, foreach prints the name | |
217 | of each submodule before evaluating the command. | |
218 | If `--recursive` is given, submodules are traversed recursively (i.e. | |
219 | the given shell command is evaluated in nested submodules as well). | |
220 | A non-zero return from the command in any submodule causes | |
221 | the processing to terminate. This can be overridden by adding '|| :' | |
222 | to the end of the command. | |
223 | + | |
224 | As an example, the command below will show the path and currently | |
225 | checked out commit for each submodule: | |
226 | + | |
227 | -------------- | |
228 | git submodule foreach 'echo $path `git rev-parse HEAD`' | |
229 | -------------- | |
230 | ||
231 | sync [--recursive] [--] [<path>...]:: | |
232 | Synchronizes submodules' remote URL configuration setting | |
233 | to the value specified in .gitmodules. It will only affect those | |
234 | submodules which already have a URL entry in .git/config (that is the | |
235 | case when they are initialized or freshly added). This is useful when | |
236 | submodule URLs change upstream and you need to update your local | |
237 | repositories accordingly. | |
238 | + | |
239 | "git submodule sync" synchronizes all submodules while | |
240 | "git submodule sync \-- A" synchronizes submodule "A" only. | |
241 | + | |
242 | If `--recursive` is specified, this command will recurse into the | |
243 | registered submodules, and sync any nested submodules within. | |
244 | ||
245 | absorbgitdirs:: | |
246 | If a git directory of a submodule is inside the submodule, | |
247 | move the git directory of the submodule into its superprojects | |
248 | `$GIT_DIR/modules` path and then connect the git directory and | |
249 | its working directory by setting the `core.worktree` and adding | |
250 | a .git file pointing to the git directory embedded in the | |
251 | superprojects git directory. | |
252 | + | |
253 | A repository that was cloned independently and later added as a submodule or | |
254 | old setups have the submodules git directory inside the submodule instead of | |
255 | embedded into the superprojects git directory. | |
256 | + | |
257 | This command is recursive by default. | |
258 | ||
259 | OPTIONS | |
260 | ------- | |
261 | -q:: | |
262 | --quiet:: | |
263 | Only print error messages. | |
264 | ||
265 | --all:: | |
266 | This option is only valid for the deinit command. Unregister all | |
267 | submodules in the working tree. | |
268 | ||
269 | -b:: | |
270 | --branch:: | |
271 | Branch of repository to add as submodule. | |
272 | The name of the branch is recorded as `submodule.<name>.branch` in | |
273 | `.gitmodules` for `update --remote`. A special value of `.` is used to | |
274 | indicate that the name of the branch in the submodule should be the | |
275 | same name as the current branch in the current repository. | |
276 | ||
277 | -f:: | |
278 | --force:: | |
279 | This option is only valid for add, deinit and update commands. | |
280 | When running add, allow adding an otherwise ignored submodule path. | |
281 | When running deinit the submodule working trees will be removed even | |
282 | if they contain local changes. | |
283 | When running update (only effective with the checkout procedure), | |
284 | throw away local changes in submodules when switching to a | |
285 | different commit; and always run a checkout operation in the | |
286 | submodule, even if the commit listed in the index of the | |
287 | containing repository matches the commit checked out in the | |
288 | submodule. | |
289 | ||
290 | --cached:: | |
291 | This option is only valid for status and summary commands. These | |
292 | commands typically use the commit found in the submodule HEAD, but | |
293 | with this option, the commit stored in the index is used instead. | |
294 | ||
295 | --files:: | |
296 | This option is only valid for the summary command. This command | |
297 | compares the commit in the index with that in the submodule HEAD | |
298 | when this option is used. | |
299 | ||
300 | -n:: | |
301 | --summary-limit:: | |
302 | This option is only valid for the summary command. | |
303 | Limit the summary size (number of commits shown in total). | |
304 | Giving 0 will disable the summary; a negative number means unlimited | |
305 | (the default). This limit only applies to modified submodules. The | |
306 | size is always limited to 1 for added/deleted/typechanged submodules. | |
307 | ||
308 | --remote:: | |
309 | This option is only valid for the update command. Instead of using | |
310 | the superproject's recorded SHA-1 to update the submodule, use the | |
311 | status of the submodule's remote-tracking branch. The remote used | |
312 | is branch's remote (`branch.<name>.remote`), defaulting to `origin`. | |
313 | The remote branch used defaults to `master`, but the branch name may | |
314 | be overridden by setting the `submodule.<name>.branch` option in | |
315 | either `.gitmodules` or `.git/config` (with `.git/config` taking | |
316 | precedence). | |
317 | + | |
318 | This works for any of the supported update procedures (`--checkout`, | |
319 | `--rebase`, etc.). The only change is the source of the target SHA-1. | |
320 | For example, `submodule update --remote --merge` will merge upstream | |
321 | submodule changes into the submodules, while `submodule update | |
322 | --merge` will merge superproject gitlink changes into the submodules. | |
323 | + | |
324 | In order to ensure a current tracking branch state, `update --remote` | |
325 | fetches the submodule's remote repository before calculating the | |
326 | SHA-1. If you don't want to fetch, you should use `submodule update | |
327 | --remote --no-fetch`. | |
328 | + | |
329 | Use this option to integrate changes from the upstream subproject with | |
330 | your submodule's current HEAD. Alternatively, you can run `git pull` | |
331 | from the submodule, which is equivalent except for the remote branch | |
332 | name: `update --remote` uses the default upstream repository and | |
333 | `submodule.<name>.branch`, while `git pull` uses the submodule's | |
334 | `branch.<name>.merge`. Prefer `submodule.<name>.branch` if you want | |
335 | to distribute the default upstream branch with the superproject and | |
336 | `branch.<name>.merge` if you want a more native feel while working in | |
337 | the submodule itself. | |
338 | ||
339 | -N:: | |
340 | --no-fetch:: | |
341 | This option is only valid for the update command. | |
342 | Don't fetch new objects from the remote site. | |
343 | ||
344 | --checkout:: | |
345 | This option is only valid for the update command. | |
346 | Checkout the commit recorded in the superproject on a detached HEAD | |
347 | in the submodule. This is the default behavior, the main use of | |
348 | this option is to override `submodule.$name.update` when set to | |
349 | a value other than `checkout`. | |
350 | If the key `submodule.$name.update` is either not explicitly set or | |
351 | set to `checkout`, this option is implicit. | |
352 | ||
353 | --merge:: | |
354 | This option is only valid for the update command. | |
355 | Merge the commit recorded in the superproject into the current branch | |
356 | of the submodule. If this option is given, the submodule's HEAD will | |
357 | not be detached. If a merge failure prevents this process, you will | |
358 | have to resolve the resulting conflicts within the submodule with the | |
359 | usual conflict resolution tools. | |
360 | If the key `submodule.$name.update` is set to `merge`, this option is | |
361 | implicit. | |
362 | ||
363 | --rebase:: | |
364 | This option is only valid for the update command. | |
365 | Rebase the current branch onto the commit recorded in the | |
366 | superproject. If this option is given, the submodule's HEAD will not | |
367 | be detached. If a merge failure prevents this process, you will have | |
368 | to resolve these failures with linkgit:git-rebase[1]. | |
369 | If the key `submodule.$name.update` is set to `rebase`, this option is | |
370 | implicit. | |
371 | ||
372 | --init:: | |
373 | This option is only valid for the update command. | |
374 | Initialize all submodules for which "git submodule init" has not been | |
375 | called so far before updating. | |
376 | ||
377 | --name:: | |
378 | This option is only valid for the add command. It sets the submodule's | |
379 | name to the given string instead of defaulting to its path. The name | |
380 | must be valid as a directory name and may not end with a '/'. | |
381 | ||
382 | --reference <repository>:: | |
383 | This option is only valid for add and update commands. These | |
384 | commands sometimes need to clone a remote repository. In this case, | |
385 | this option will be passed to the linkgit:git-clone[1] command. | |
386 | + | |
387 | *NOTE*: Do *not* use this option unless you have read the note | |
388 | for linkgit:git-clone[1]'s `--reference` and `--shared` options carefully. | |
389 | ||
390 | --recursive:: | |
391 | This option is only valid for foreach, update, status and sync commands. | |
392 | Traverse submodules recursively. The operation is performed not | |
393 | only in the submodules of the current repo, but also | |
394 | in any nested submodules inside those submodules (and so on). | |
395 | ||
396 | --depth:: | |
397 | This option is valid for add and update commands. Create a 'shallow' | |
398 | clone with a history truncated to the specified number of revisions. | |
399 | See linkgit:git-clone[1] | |
400 | ||
401 | --[no-]recommend-shallow:: | |
402 | This option is only valid for the update command. | |
403 | The initial clone of a submodule will use the recommended | |
404 | `submodule.<name>.shallow` as provided by the .gitmodules file | |
405 | by default. To ignore the suggestions use `--no-recommend-shallow`. | |
406 | ||
407 | -j <n>:: | |
408 | --jobs <n>:: | |
409 | This option is only valid for the update command. | |
410 | Clone new submodules in parallel with as many jobs. | |
411 | Defaults to the `submodule.fetchJobs` option. | |
412 | ||
413 | <path>...:: | |
414 | Paths to submodule(s). When specified this will restrict the command | |
415 | to only operate on the submodules found at the specified paths. | |
416 | (This argument is required with add). | |
417 | ||
418 | FILES | |
419 | ----- | |
420 | When initializing submodules, a .gitmodules file in the top-level directory | |
421 | of the containing repository is used to find the url of each submodule. | |
422 | This file should be formatted in the same way as `$GIT_DIR/config`. The key | |
423 | to each submodule url is "submodule.$name.url". See linkgit:gitmodules[5] | |
424 | for details. | |
425 | ||
426 | GIT | |
427 | --- | |
428 | Part of the linkgit:git[1] suite |