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