]>
Commit | Line | Data |
---|---|---|
74703a1e SB |
1 | #include "builtin.h" |
2 | #include "cache.h" | |
3 | #include "parse-options.h" | |
4 | #include "quote.h" | |
5 | #include "pathspec.h" | |
6 | #include "dir.h" | |
7 | #include "utf8.h" | |
0ea306ef SB |
8 | #include "submodule.h" |
9 | #include "submodule-config.h" | |
10 | #include "string-list.h" | |
ee8838d1 | 11 | #include "run-command.h" |
74703a1e SB |
12 | |
13 | struct module_list { | |
14 | const struct cache_entry **entries; | |
15 | int alloc, nr; | |
16 | }; | |
17 | #define MODULE_LIST_INIT { NULL, 0, 0 } | |
18 | ||
19 | static int module_list_compute(int argc, const char **argv, | |
20 | const char *prefix, | |
21 | struct pathspec *pathspec, | |
22 | struct module_list *list) | |
23 | { | |
24 | int i, result = 0; | |
25 | char *max_prefix, *ps_matched = NULL; | |
26 | int max_prefix_len; | |
27 | parse_pathspec(pathspec, 0, | |
28 | PATHSPEC_PREFER_FULL | | |
29 | PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP, | |
30 | prefix, argv); | |
31 | ||
32 | /* Find common prefix for all pathspec's */ | |
33 | max_prefix = common_prefix(pathspec); | |
34 | max_prefix_len = max_prefix ? strlen(max_prefix) : 0; | |
35 | ||
36 | if (pathspec->nr) | |
37 | ps_matched = xcalloc(pathspec->nr, 1); | |
38 | ||
39 | if (read_cache() < 0) | |
40 | die(_("index file corrupt")); | |
41 | ||
42 | for (i = 0; i < active_nr; i++) { | |
43 | const struct cache_entry *ce = active_cache[i]; | |
44 | ||
45 | if (!S_ISGITLINK(ce->ce_mode) || | |
46 | !match_pathspec(pathspec, ce->name, ce_namelen(ce), | |
47 | max_prefix_len, ps_matched, 1)) | |
48 | continue; | |
49 | ||
50 | ALLOC_GROW(list->entries, list->nr + 1, list->alloc); | |
51 | list->entries[list->nr++] = ce; | |
52 | while (i + 1 < active_nr && | |
53 | !strcmp(ce->name, active_cache[i + 1]->name)) | |
54 | /* | |
55 | * Skip entries with the same name in different stages | |
56 | * to make sure an entry is returned only once. | |
57 | */ | |
58 | i++; | |
59 | } | |
60 | free(max_prefix); | |
61 | ||
62 | if (ps_matched && report_path_error(ps_matched, pathspec, prefix)) | |
63 | result = -1; | |
64 | ||
65 | free(ps_matched); | |
66 | ||
67 | return result; | |
68 | } | |
69 | ||
70 | static int module_list(int argc, const char **argv, const char *prefix) | |
71 | { | |
72 | int i; | |
73 | struct pathspec pathspec; | |
74 | struct module_list list = MODULE_LIST_INIT; | |
75 | ||
76 | struct option module_list_options[] = { | |
77 | OPT_STRING(0, "prefix", &prefix, | |
78 | N_("path"), | |
79 | N_("alternative anchor for relative paths")), | |
80 | OPT_END() | |
81 | }; | |
82 | ||
83 | const char *const git_submodule_helper_usage[] = { | |
84 | N_("git submodule--helper list [--prefix=<path>] [<path>...]"), | |
85 | NULL | |
86 | }; | |
87 | ||
88 | argc = parse_options(argc, argv, prefix, module_list_options, | |
89 | git_submodule_helper_usage, 0); | |
90 | ||
91 | if (module_list_compute(argc, argv, prefix, &pathspec, &list) < 0) { | |
92 | printf("#unmatched\n"); | |
93 | return 1; | |
94 | } | |
95 | ||
96 | for (i = 0; i < list.nr; i++) { | |
97 | const struct cache_entry *ce = list.entries[i]; | |
98 | ||
99 | if (ce_stage(ce)) | |
100 | printf("%06o %s U\t", ce->ce_mode, sha1_to_hex(null_sha1)); | |
101 | else | |
102 | printf("%06o %s %d\t", ce->ce_mode, sha1_to_hex(ce->sha1), ce_stage(ce)); | |
103 | ||
104 | utf8_fprintf(stdout, "%s\n", ce->name); | |
105 | } | |
106 | return 0; | |
107 | } | |
108 | ||
0ea306ef SB |
109 | static int module_name(int argc, const char **argv, const char *prefix) |
110 | { | |
111 | const struct submodule *sub; | |
112 | ||
113 | if (argc != 2) | |
114 | usage(_("git submodule--helper name <path>")); | |
115 | ||
116 | gitmodules_config(); | |
117 | sub = submodule_from_path(null_sha1, argv[1]); | |
118 | ||
119 | if (!sub) | |
120 | die(_("no submodule mapping found in .gitmodules for path '%s'"), | |
121 | argv[1]); | |
122 | ||
123 | printf("%s\n", sub->name); | |
124 | ||
125 | return 0; | |
126 | } | |
ee8838d1 SB |
127 | static int clone_submodule(const char *path, const char *gitdir, const char *url, |
128 | const char *depth, const char *reference, int quiet) | |
129 | { | |
130 | struct child_process cp; | |
131 | child_process_init(&cp); | |
132 | ||
133 | argv_array_push(&cp.args, "clone"); | |
134 | argv_array_push(&cp.args, "--no-checkout"); | |
135 | if (quiet) | |
136 | argv_array_push(&cp.args, "--quiet"); | |
137 | if (depth && *depth) | |
138 | argv_array_pushl(&cp.args, "--depth", depth, NULL); | |
139 | if (reference && *reference) | |
140 | argv_array_pushl(&cp.args, "--reference", reference, NULL); | |
141 | if (gitdir && *gitdir) | |
142 | argv_array_pushl(&cp.args, "--separate-git-dir", gitdir, NULL); | |
143 | ||
144 | argv_array_push(&cp.args, url); | |
145 | argv_array_push(&cp.args, path); | |
146 | ||
147 | cp.git_cmd = 1; | |
148 | cp.env = local_repo_env; | |
149 | cp.no_stdin = 1; | |
150 | ||
151 | return run_command(&cp); | |
152 | } | |
153 | ||
154 | static int module_clone(int argc, const char **argv, const char *prefix) | |
155 | { | |
156 | const char *path = NULL, *name = NULL, *url = NULL; | |
157 | const char *reference = NULL, *depth = NULL; | |
158 | int quiet = 0; | |
159 | FILE *submodule_dot_git; | |
160 | char *sm_gitdir, *cwd, *p; | |
161 | struct strbuf rel_path = STRBUF_INIT; | |
162 | struct strbuf sb = STRBUF_INIT; | |
163 | ||
164 | struct option module_clone_options[] = { | |
165 | OPT_STRING(0, "prefix", &prefix, | |
166 | N_("path"), | |
167 | N_("alternative anchor for relative paths")), | |
168 | OPT_STRING(0, "path", &path, | |
169 | N_("path"), | |
170 | N_("where the new submodule will be cloned to")), | |
171 | OPT_STRING(0, "name", &name, | |
172 | N_("string"), | |
173 | N_("name of the new submodule")), | |
174 | OPT_STRING(0, "url", &url, | |
175 | N_("string"), | |
176 | N_("url where to clone the submodule from")), | |
177 | OPT_STRING(0, "reference", &reference, | |
178 | N_("string"), | |
179 | N_("reference repository")), | |
180 | OPT_STRING(0, "depth", &depth, | |
181 | N_("string"), | |
182 | N_("depth for shallow clones")), | |
183 | OPT__QUIET(&quiet, "Suppress output for cloning a submodule"), | |
184 | OPT_END() | |
185 | }; | |
186 | ||
187 | const char *const git_submodule_helper_usage[] = { | |
188 | N_("git submodule--helper clone [--prefix=<path>] [--quiet] " | |
7dad2633 JK |
189 | "[--reference <repository>] [--name <name>] [--depth <depth>] " |
190 | "--url <url> --path <path>"), | |
ee8838d1 SB |
191 | NULL |
192 | }; | |
193 | ||
194 | argc = parse_options(argc, argv, prefix, module_clone_options, | |
195 | git_submodule_helper_usage, 0); | |
196 | ||
7dad2633 | 197 | if (argc || !url || !path) |
08e0970a JK |
198 | usage_with_options(git_submodule_helper_usage, |
199 | module_clone_options); | |
200 | ||
ee8838d1 SB |
201 | strbuf_addf(&sb, "%s/modules/%s", get_git_dir(), name); |
202 | sm_gitdir = strbuf_detach(&sb, NULL); | |
203 | ||
204 | if (!file_exists(sm_gitdir)) { | |
205 | if (safe_create_leading_directories_const(sm_gitdir) < 0) | |
206 | die(_("could not create directory '%s'"), sm_gitdir); | |
207 | if (clone_submodule(path, sm_gitdir, url, depth, reference, quiet)) | |
208 | die(_("clone of '%s' into submodule path '%s' failed"), | |
209 | url, path); | |
210 | } else { | |
211 | if (safe_create_leading_directories_const(path) < 0) | |
212 | die(_("could not create directory '%s'"), path); | |
213 | strbuf_addf(&sb, "%s/index", sm_gitdir); | |
214 | unlink_or_warn(sb.buf); | |
215 | strbuf_reset(&sb); | |
216 | } | |
217 | ||
218 | /* Write a .git file in the submodule to redirect to the superproject. */ | |
219 | if (safe_create_leading_directories_const(path) < 0) | |
220 | die(_("could not create directory '%s'"), path); | |
221 | ||
222 | if (path && *path) | |
223 | strbuf_addf(&sb, "%s/.git", path); | |
224 | else | |
225 | strbuf_addstr(&sb, ".git"); | |
226 | ||
227 | if (safe_create_leading_directories_const(sb.buf) < 0) | |
228 | die(_("could not create leading directories of '%s'"), sb.buf); | |
229 | submodule_dot_git = fopen(sb.buf, "w"); | |
230 | if (!submodule_dot_git) | |
231 | die_errno(_("cannot open file '%s'"), sb.buf); | |
232 | ||
233 | fprintf(submodule_dot_git, "gitdir: %s\n", | |
234 | relative_path(sm_gitdir, path, &rel_path)); | |
235 | if (fclose(submodule_dot_git)) | |
236 | die(_("could not close file %s"), sb.buf); | |
237 | strbuf_reset(&sb); | |
238 | strbuf_reset(&rel_path); | |
239 | ||
240 | cwd = xgetcwd(); | |
241 | /* Redirect the worktree of the submodule in the superproject's config */ | |
242 | if (!is_absolute_path(sm_gitdir)) { | |
243 | strbuf_addf(&sb, "%s/%s", cwd, sm_gitdir); | |
244 | free(sm_gitdir); | |
245 | sm_gitdir = strbuf_detach(&sb, NULL); | |
246 | } | |
247 | ||
248 | strbuf_addf(&sb, "%s/%s", cwd, path); | |
249 | p = git_pathdup_submodule(path, "config"); | |
250 | if (!p) | |
251 | die(_("could not get submodule directory for '%s'"), path); | |
252 | git_config_set_in_file(p, "core.worktree", | |
253 | relative_path(sb.buf, sm_gitdir, &rel_path)); | |
254 | strbuf_release(&sb); | |
255 | strbuf_release(&rel_path); | |
256 | free(sm_gitdir); | |
257 | free(cwd); | |
258 | free(p); | |
259 | return 0; | |
260 | } | |
74703a1e SB |
261 | |
262 | struct cmd_struct { | |
263 | const char *cmd; | |
264 | int (*fn)(int, const char **, const char *); | |
265 | }; | |
266 | ||
267 | static struct cmd_struct commands[] = { | |
268 | {"list", module_list}, | |
0ea306ef | 269 | {"name", module_name}, |
ee8838d1 | 270 | {"clone", module_clone}, |
74703a1e SB |
271 | }; |
272 | ||
273 | int cmd_submodule__helper(int argc, const char **argv, const char *prefix) | |
274 | { | |
275 | int i; | |
276 | if (argc < 2) | |
277 | die(_("fatal: submodule--helper subcommand must be " | |
278 | "called with a subcommand")); | |
279 | ||
280 | for (i = 0; i < ARRAY_SIZE(commands); i++) | |
281 | if (!strcmp(argv[1], commands[i].cmd)) | |
282 | return commands[i].fn(argc - 1, argv + 1, prefix); | |
283 | ||
284 | die(_("fatal: '%s' is not a valid submodule--helper " | |
285 | "subcommand"), argv[1]); | |
286 | } |