submodule: modernize ok_to_remove_submodule to use argv_array
[git/git.git] / submodule.c
CommitLineData
752c0c24 1#include "cache.h"
851e18c3 2#include "submodule-config.h"
752c0c24
JS
3#include "submodule.h"
4#include "dir.h"
5#include "diff.h"
6#include "commit.h"
7#include "revision.h"
ee6fc514 8#include "run-command.h"
c7e1a736 9#include "diffcore.h"
68d03e4a 10#include "refs.h"
aee9c7d6 11#include "string-list.h"
6859de45 12#include "sha1-array.h"
c1189cae 13#include "argv-array.h"
5fee9952 14#include "blob.h"
fe85ee6e 15#include "thread-utils.h"
4638728c 16#include "quote.h"
f6f85861 17#include "worktree.h"
aee9c7d6 18
88a21979 19static int config_fetch_recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND;
a028a193 20static int parallel_jobs = 1;
2721ce21 21static struct string_list changed_submodule_paths = STRING_LIST_INIT_NODUP;
6859de45
JK
22static int initialized_fetch_ref_tips;
23static struct sha1_array ref_tips_before_fetch;
24static struct sha1_array ref_tips_after_fetch;
25
d4e98b58
JL
26/*
27 * The following flag is set if the .gitmodules file is unmerged. We then
28 * disable recursion for all submodules where .git/config doesn't have a
29 * matching config entry because we can't guess what might be configured in
30 * .gitmodules unless the user resolves the conflict. When a command line
31 * option is given (which always overrides configuration) this flag will be
32 * ignored.
33 */
34static int gitmodules_is_unmerged;
752c0c24 35
5fee9952
JL
36/*
37 * This flag is set if the .gitmodules file had unstaged modifications on
38 * startup. This must be checked before allowing modifications to the
39 * .gitmodules file with the intention to stage them later, because when
40 * continuing we would stage the modifications the user didn't stage herself
41 * too. That might change in a future version when we learn to stage the
42 * changes we do ourselves without staging any previous modifications.
43 */
44static int gitmodules_is_modified;
45
5fee9952
JL
46int is_staging_gitmodules_ok(void)
47{
48 return !gitmodules_is_modified;
49}
50
0656781f
JL
51/*
52 * Try to update the "path" entry in the "submodule.<name>" section of the
53 * .gitmodules file. Return 0 only if a .gitmodules file was found, a section
54 * with the correct path=<oldpath> setting was found and we could update it.
55 */
56int update_path_in_gitmodules(const char *oldpath, const char *newpath)
57{
58 struct strbuf entry = STRBUF_INIT;
851e18c3 59 const struct submodule *submodule;
0656781f
JL
60
61 if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
62 return -1;
63
64 if (gitmodules_is_unmerged)
65 die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
66
851e18c3
HV
67 submodule = submodule_from_path(null_sha1, oldpath);
68 if (!submodule || !submodule->name) {
0656781f
JL
69 warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
70 return -1;
71 }
72 strbuf_addstr(&entry, "submodule.");
851e18c3 73 strbuf_addstr(&entry, submodule->name);
0656781f 74 strbuf_addstr(&entry, ".path");
30598ad0 75 if (git_config_set_in_file_gently(".gitmodules", entry.buf, newpath) < 0) {
0656781f
JL
76 /* Maybe the user already did that, don't error out here */
77 warning(_("Could not update .gitmodules entry %s"), entry.buf);
78 strbuf_release(&entry);
79 return -1;
80 }
81 strbuf_release(&entry);
82 return 0;
83}
84
95c16418
JL
85/*
86 * Try to remove the "submodule.<name>" section from .gitmodules where the given
87 * path is configured. Return 0 only if a .gitmodules file was found, a section
88 * with the correct path=<path> setting was found and we could remove it.
89 */
90int remove_path_from_gitmodules(const char *path)
91{
92 struct strbuf sect = STRBUF_INIT;
851e18c3 93 const struct submodule *submodule;
95c16418
JL
94
95 if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
96 return -1;
97
98 if (gitmodules_is_unmerged)
99 die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
100
851e18c3
HV
101 submodule = submodule_from_path(null_sha1, path);
102 if (!submodule || !submodule->name) {
95c16418
JL
103 warning(_("Could not find section in .gitmodules where path=%s"), path);
104 return -1;
105 }
106 strbuf_addstr(&sect, "submodule.");
851e18c3 107 strbuf_addstr(&sect, submodule->name);
95c16418
JL
108 if (git_config_rename_section_in_file(".gitmodules", sect.buf, NULL) < 0) {
109 /* Maybe the user already did that, don't error out here */
110 warning(_("Could not remove .gitmodules entry for %s"), path);
111 strbuf_release(&sect);
112 return -1;
113 }
114 strbuf_release(&sect);
115 return 0;
116}
117
5fee9952
JL
118void stage_updated_gitmodules(void)
119{
bc8d6b9b 120 if (add_file_to_cache(".gitmodules", 0))
5fee9952
JL
121 die(_("staging updated .gitmodules failed"));
122}
123
cb58c932 124static int add_submodule_odb(const char *path)
752c0c24
JS
125{
126 struct strbuf objects_directory = STRBUF_INIT;
de7a7960 127 int ret = 0;
752c0c24 128
99b43a61
JK
129 ret = strbuf_git_path_submodule(&objects_directory, path, "objects/");
130 if (ret)
131 goto done;
de7a7960
JL
132 if (!is_directory(objects_directory.buf)) {
133 ret = -1;
134 goto done;
135 }
a5b34d21 136 add_to_alternates_memory(objects_directory.buf);
de7a7960
JL
137done:
138 strbuf_release(&objects_directory);
139 return ret;
752c0c24
JS
140}
141
aee9c7d6
JL
142void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
143 const char *path)
144{
851e18c3
HV
145 const struct submodule *submodule = submodule_from_path(null_sha1, path);
146 if (submodule) {
147 if (submodule->ignore)
148 handle_ignore_submodules_arg(diffopt, submodule->ignore);
d4e98b58
JL
149 else if (gitmodules_is_unmerged)
150 DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
aee9c7d6
JL
151 }
152}
153
7dce19d3 154int submodule_config(const char *var, const char *value, void *cb)
302ad7a9 155{
a028a193
SB
156 if (!strcmp(var, "submodule.fetchjobs")) {
157 parallel_jobs = git_config_int(var, value);
158 if (parallel_jobs < 0)
159 die(_("negative values not allowed for submodule.fetchJobs"));
160 return 0;
161 } else if (starts_with(var, "submodule."))
302ad7a9 162 return parse_submodule_config_option(var, value);
be254a0e 163 else if (!strcmp(var, "fetch.recursesubmodules")) {
1fb25502 164 config_fetch_recurse_submodules = parse_fetch_recurse_submodules_arg(var, value);
be254a0e
JL
165 return 0;
166 }
302ad7a9
JL
167 return 0;
168}
169
170void gitmodules_config(void)
171{
172 const char *work_tree = get_git_work_tree();
173 if (work_tree) {
174 struct strbuf gitmodules_path = STRBUF_INIT;
d4e98b58 175 int pos;
302ad7a9
JL
176 strbuf_addstr(&gitmodules_path, work_tree);
177 strbuf_addstr(&gitmodules_path, "/.gitmodules");
d4e98b58
JL
178 if (read_cache() < 0)
179 die("index file corrupt");
180 pos = cache_name_pos(".gitmodules", 11);
181 if (pos < 0) { /* .gitmodules not found or isn't merged */
182 pos = -1 - pos;
183 if (active_nr > pos) { /* there is a .gitmodules */
184 const struct cache_entry *ce = active_cache[pos];
185 if (ce_namelen(ce) == 11 &&
186 !memcmp(ce->name, ".gitmodules", 11))
187 gitmodules_is_unmerged = 1;
188 }
5fee9952
JL
189 } else if (pos < active_nr) {
190 struct stat st;
191 if (lstat(".gitmodules", &st) == 0 &&
192 ce_match_stat(active_cache[pos], &st, 0) & DATA_CHANGED)
193 gitmodules_is_modified = 1;
d4e98b58
JL
194 }
195
196 if (!gitmodules_is_unmerged)
197 git_config_from_file(submodule_config, gitmodules_path.buf, NULL);
302ad7a9
JL
198 strbuf_release(&gitmodules_path);
199 }
200}
201
ea2fa5a3
SB
202int parse_submodule_update_strategy(const char *value,
203 struct submodule_update_strategy *dst)
204{
205 free((void*)dst->command);
206 dst->command = NULL;
207 if (!strcmp(value, "none"))
208 dst->type = SM_UPDATE_NONE;
209 else if (!strcmp(value, "checkout"))
210 dst->type = SM_UPDATE_CHECKOUT;
211 else if (!strcmp(value, "rebase"))
212 dst->type = SM_UPDATE_REBASE;
213 else if (!strcmp(value, "merge"))
214 dst->type = SM_UPDATE_MERGE;
215 else if (skip_prefix(value, "!", &value)) {
216 dst->type = SM_UPDATE_COMMAND;
217 dst->command = xstrdup(value);
218 } else
219 return -1;
220 return 0;
221}
222
3604242f
SB
223const char *submodule_strategy_to_string(const struct submodule_update_strategy *s)
224{
225 struct strbuf sb = STRBUF_INIT;
226 switch (s->type) {
227 case SM_UPDATE_CHECKOUT:
228 return "checkout";
229 case SM_UPDATE_MERGE:
230 return "merge";
231 case SM_UPDATE_REBASE:
232 return "rebase";
233 case SM_UPDATE_NONE:
234 return "none";
235 case SM_UPDATE_UNSPECIFIED:
236 return NULL;
237 case SM_UPDATE_COMMAND:
238 strbuf_addf(&sb, "!%s", s->command);
239 return strbuf_detach(&sb, NULL);
240 }
241 return NULL;
242}
243
46a958b3
JL
244void handle_ignore_submodules_arg(struct diff_options *diffopt,
245 const char *arg)
246{
be4f2b40
JS
247 DIFF_OPT_CLR(diffopt, IGNORE_SUBMODULES);
248 DIFF_OPT_CLR(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
249 DIFF_OPT_CLR(diffopt, IGNORE_DIRTY_SUBMODULES);
250
46a958b3
JL
251 if (!strcmp(arg, "all"))
252 DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
253 else if (!strcmp(arg, "untracked"))
254 DIFF_OPT_SET(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
255 else if (!strcmp(arg, "dirty"))
256 DIFF_OPT_SET(diffopt, IGNORE_DIRTY_SUBMODULES);
aee9c7d6 257 else if (strcmp(arg, "none"))
46a958b3
JL
258 die("bad --ignore-submodules argument: %s", arg);
259}
260
808a95dc
JN
261static int prepare_submodule_summary(struct rev_info *rev, const char *path,
262 struct commit *left, struct commit *right,
8e6df650 263 struct commit_list *merge_bases)
808a95dc 264{
8e6df650 265 struct commit_list *list;
808a95dc
JN
266
267 init_revisions(rev, NULL);
268 setup_revisions(0, NULL, rev, NULL);
269 rev->left_right = 1;
270 rev->first_parent_only = 1;
271 left->object.flags |= SYMMETRIC_LEFT;
272 add_pending_object(rev, &left->object, path);
273 add_pending_object(rev, &right->object, path);
808a95dc
JN
274 for (list = merge_bases; list; list = list->next) {
275 list->item->object.flags |= UNINTERESTING;
276 add_pending_object(rev, &list->item->object,
f2fd0760 277 oid_to_hex(&list->item->object.oid));
808a95dc
JN
278 }
279 return prepare_revision_walk(rev);
280}
281
282static void print_submodule_summary(struct rev_info *rev, FILE *f,
0f33a067 283 const char *line_prefix,
808a95dc
JN
284 const char *del, const char *add, const char *reset)
285{
286 static const char format[] = " %m %s";
287 struct strbuf sb = STRBUF_INIT;
288 struct commit *commit;
289
290 while ((commit = get_revision(rev))) {
291 struct pretty_print_context ctx = {0};
292 ctx.date_mode = rev->date_mode;
ecaee805 293 ctx.output_encoding = get_log_output_encoding();
808a95dc 294 strbuf_setlen(&sb, 0);
0f33a067 295 strbuf_addstr(&sb, line_prefix);
808a95dc
JN
296 if (commit->object.flags & SYMMETRIC_LEFT) {
297 if (del)
298 strbuf_addstr(&sb, del);
299 }
300 else if (add)
301 strbuf_addstr(&sb, add);
302 format_commit_message(commit, format, &sb, &ctx);
303 if (reset)
304 strbuf_addstr(&sb, reset);
305 strbuf_addch(&sb, '\n');
306 fprintf(f, "%s", sb.buf);
307 }
308 strbuf_release(&sb);
309}
310
8e6df650
JK
311/* Helper function to display the submodule header line prior to the full
312 * summary output. If it can locate the submodule objects directory it will
313 * attempt to lookup both the left and right commits and put them into the
314 * left and right pointers.
315 */
316static void show_submodule_header(FILE *f, const char *path,
0f33a067 317 const char *line_prefix,
602a283a 318 struct object_id *one, struct object_id *two,
4e215131 319 unsigned dirty_submodule, const char *meta,
8e6df650
JK
320 const char *reset,
321 struct commit **left, struct commit **right,
322 struct commit_list **merge_bases)
752c0c24 323{
752c0c24
JS
324 const char *message = NULL;
325 struct strbuf sb = STRBUF_INIT;
752c0c24
JS
326 int fast_forward = 0, fast_backward = 0;
327
c7e1a736 328 if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
0f33a067
JK
329 fprintf(f, "%sSubmodule %s contains untracked content\n",
330 line_prefix, path);
c7e1a736 331 if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
0f33a067
JK
332 fprintf(f, "%sSubmodule %s contains modified content\n",
333 line_prefix, path);
c7e1a736 334
8e6df650
JK
335 if (is_null_oid(one))
336 message = "(new submodule)";
337 else if (is_null_oid(two))
338 message = "(submodule deleted)";
339
340 if (add_submodule_odb(path)) {
341 if (!message)
342 message = "(not initialized)";
343 goto output_header;
344 }
345
346 /*
347 * Attempt to lookup the commit references, and determine if this is
348 * a fast forward or fast backwards update.
349 */
350 *left = lookup_commit_reference(one->hash);
351 *right = lookup_commit_reference(two->hash);
352
353 /*
354 * Warn about missing commits in the submodule project, but only if
355 * they aren't null.
356 */
357 if ((!is_null_oid(one) && !*left) ||
358 (!is_null_oid(two) && !*right))
359 message = "(commits not present)";
360
361 *merge_bases = get_merge_bases(*left, *right);
362 if (*merge_bases) {
363 if ((*merge_bases)->item == *left)
364 fast_forward = 1;
365 else if ((*merge_bases)->item == *right)
366 fast_backward = 1;
367 }
368
602a283a 369 if (!oidcmp(one, two)) {
c7e1a736
JL
370 strbuf_release(&sb);
371 return;
372 }
373
8e6df650 374output_header:
a94bb683 375 strbuf_addf(&sb, "%s%sSubmodule %s ", line_prefix, meta, path);
69e65449 376 strbuf_add_unique_abbrev(&sb, one->hash, DEFAULT_ABBREV);
a94bb683 377 strbuf_addstr(&sb, (fast_backward || fast_forward) ? ".." : "...");
f0798e6c 378 strbuf_add_unique_abbrev(&sb, two->hash, DEFAULT_ABBREV);
752c0c24 379 if (message)
4e215131 380 strbuf_addf(&sb, " %s%s\n", message, reset);
752c0c24 381 else
4e215131 382 strbuf_addf(&sb, "%s:%s\n", fast_backward ? " (rewind)" : "", reset);
752c0c24
JS
383 fwrite(sb.buf, sb.len, 1, f);
384
752c0c24
JS
385 strbuf_release(&sb);
386}
ee6fc514 387
8e6df650
JK
388void show_submodule_summary(FILE *f, const char *path,
389 const char *line_prefix,
390 struct object_id *one, struct object_id *two,
391 unsigned dirty_submodule, const char *meta,
392 const char *del, const char *add, const char *reset)
393{
394 struct rev_info rev;
395 struct commit *left = NULL, *right = NULL;
396 struct commit_list *merge_bases = NULL;
397
398 show_submodule_header(f, path, line_prefix, one, two, dirty_submodule,
399 meta, reset, &left, &right, &merge_bases);
400
401 /*
402 * If we don't have both a left and a right pointer, there is no
403 * reason to try and display a summary. The header line should contain
404 * all the information the user needs.
405 */
406 if (!left || !right)
407 goto out;
408
409 /* Treat revision walker failure the same as missing commits */
410 if (prepare_submodule_summary(&rev, path, left, right, merge_bases)) {
411 fprintf(f, "%s(revision walker failed)\n", line_prefix);
412 goto out;
413 }
414
415 print_submodule_summary(&rev, f, line_prefix, del, add, reset);
416
417out:
418 if (merge_bases)
419 free_commit_list(merge_bases);
420 clear_commit_marks(left, ~0);
421 clear_commit_marks(right, ~0);
422}
423
fd47ae6a
JK
424void show_submodule_inline_diff(FILE *f, const char *path,
425 const char *line_prefix,
426 struct object_id *one, struct object_id *two,
427 unsigned dirty_submodule, const char *meta,
428 const char *del, const char *add, const char *reset,
429 const struct diff_options *o)
430{
431 const struct object_id *old = &empty_tree_oid, *new = &empty_tree_oid;
432 struct commit *left = NULL, *right = NULL;
433 struct commit_list *merge_bases = NULL;
434 struct strbuf submodule_dir = STRBUF_INIT;
435 struct child_process cp = CHILD_PROCESS_INIT;
436
437 show_submodule_header(f, path, line_prefix, one, two, dirty_submodule,
438 meta, reset, &left, &right, &merge_bases);
439
440 /* We need a valid left and right commit to display a difference */
441 if (!(left || is_null_oid(one)) ||
442 !(right || is_null_oid(two)))
443 goto done;
444
445 if (left)
446 old = one;
447 if (right)
448 new = two;
449
450 fflush(f);
451 cp.git_cmd = 1;
452 cp.dir = path;
453 cp.out = dup(fileno(f));
454 cp.no_stdin = 1;
455
456 /* TODO: other options may need to be passed here. */
457 argv_array_push(&cp.args, "diff");
458 argv_array_pushf(&cp.args, "--line-prefix=%s", line_prefix);
459 if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
460 argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
461 o->b_prefix, path);
462 argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
463 o->a_prefix, path);
464 } else {
465 argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
466 o->a_prefix, path);
467 argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
468 o->b_prefix, path);
469 }
470 argv_array_push(&cp.args, oid_to_hex(old));
471 /*
472 * If the submodule has modified content, we will diff against the
473 * work tree, under the assumption that the user has asked for the
474 * diff format and wishes to actually see all differences even if they
475 * haven't yet been committed to the submodule yet.
476 */
477 if (!(dirty_submodule & DIRTY_SUBMODULE_MODIFIED))
478 argv_array_push(&cp.args, oid_to_hex(new));
479
480 if (run_command(&cp))
481 fprintf(f, "(diff failed)\n");
482
483done:
484 strbuf_release(&submodule_dir);
485 if (merge_bases)
486 free_commit_list(merge_bases);
487 if (left)
488 clear_commit_marks(left, ~0);
489 if (right)
490 clear_commit_marks(right, ~0);
491}
492
be254a0e
JL
493void set_config_fetch_recurse_submodules(int value)
494{
495 config_fetch_recurse_submodules = value;
496}
497
7290ef58
MH
498static int has_remote(const char *refname, const struct object_id *oid,
499 int flags, void *cb_data)
d2b17b32
FG
500{
501 return 1;
502}
503
504static int submodule_needs_pushing(const char *path, const unsigned char sha1[20])
505{
506 if (add_submodule_odb(path) || !lookup_commit_reference(sha1))
507 return 0;
508
509 if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
d3180279 510 struct child_process cp = CHILD_PROCESS_INIT;
d2b17b32
FG
511 const char *argv[] = {"rev-list", NULL, "--not", "--remotes", "-n", "1" , NULL};
512 struct strbuf buf = STRBUF_INIT;
513 int needs_pushing = 0;
514
515 argv[1] = sha1_to_hex(sha1);
d2b17b32 516 cp.argv = argv;
c12e8656 517 prepare_submodule_repo_env(&cp.env_array);
d2b17b32
FG
518 cp.git_cmd = 1;
519 cp.no_stdin = 1;
520 cp.out = -1;
521 cp.dir = path;
522 if (start_command(&cp))
523 die("Could not run 'git rev-list %s --not --remotes -n 1' command in submodule %s",
524 sha1_to_hex(sha1), path);
525 if (strbuf_read(&buf, cp.out, 41))
526 needs_pushing = 1;
527 finish_command(&cp);
528 close(cp.out);
529 strbuf_release(&buf);
530 return needs_pushing;
531 }
532
533 return 0;
534}
535
536static void collect_submodules_from_diff(struct diff_queue_struct *q,
537 struct diff_options *options,
538 void *data)
539{
540 int i;
a762e51e 541 struct string_list *needs_pushing = data;
d2b17b32
FG
542
543 for (i = 0; i < q->nr; i++) {
544 struct diff_filepair *p = q->queue[i];
545 if (!S_ISGITLINK(p->two->mode))
546 continue;
a0d12c44 547 if (submodule_needs_pushing(p->two->path, p->two->oid.hash))
a762e51e 548 string_list_insert(needs_pushing, p->two->path);
d2b17b32
FG
549 }
550}
551
a762e51e
HV
552static void find_unpushed_submodule_commits(struct commit *commit,
553 struct string_list *needs_pushing)
d2b17b32 554{
d2b17b32
FG
555 struct rev_info rev;
556
d2b17b32
FG
557 init_revisions(&rev, NULL);
558 rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
559 rev.diffopt.format_callback = collect_submodules_from_diff;
560 rev.diffopt.format_callback_data = needs_pushing;
78e98eaf 561 diff_tree_combined_merge(commit, 1, &rev);
d2b17b32
FG
562}
563
a762e51e
HV
564int find_unpushed_submodules(unsigned char new_sha1[20],
565 const char *remotes_name, struct string_list *needs_pushing)
d2b17b32
FG
566{
567 struct rev_info rev;
568 struct commit *commit;
569 const char *argv[] = {NULL, NULL, "--not", "NULL", NULL};
570 int argc = ARRAY_SIZE(argv) - 1;
571 char *sha1_copy;
a762e51e 572
d2b17b32
FG
573 struct strbuf remotes_arg = STRBUF_INIT;
574
575 strbuf_addf(&remotes_arg, "--remotes=%s", remotes_name);
576 init_revisions(&rev, NULL);
577 sha1_copy = xstrdup(sha1_to_hex(new_sha1));
578 argv[1] = sha1_copy;
579 argv[3] = remotes_arg.buf;
580 setup_revisions(argc, argv, &rev, NULL);
581 if (prepare_revision_walk(&rev))
582 die("revision walk setup failed");
583
a762e51e
HV
584 while ((commit = get_revision(&rev)) != NULL)
585 find_unpushed_submodule_commits(commit, needs_pushing);
d2b17b32 586
bcc0a3ea 587 reset_revision_walk();
d2b17b32
FG
588 free(sha1_copy);
589 strbuf_release(&remotes_arg);
590
a762e51e 591 return needs_pushing->nr;
d2b17b32
FG
592}
593
eb21c732
HV
594static int push_submodule(const char *path)
595{
596 if (add_submodule_odb(path))
597 return 1;
598
599 if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
d3180279 600 struct child_process cp = CHILD_PROCESS_INIT;
eb21c732
HV
601 const char *argv[] = {"push", NULL};
602
eb21c732 603 cp.argv = argv;
c12e8656 604 prepare_submodule_repo_env(&cp.env_array);
eb21c732
HV
605 cp.git_cmd = 1;
606 cp.no_stdin = 1;
607 cp.dir = path;
608 if (run_command(&cp))
609 return 0;
610 close(cp.out);
611 }
612
613 return 1;
614}
615
616int push_unpushed_submodules(unsigned char new_sha1[20], const char *remotes_name)
617{
618 int i, ret = 1;
f93d7c6f 619 struct string_list needs_pushing = STRING_LIST_INIT_DUP;
eb21c732
HV
620
621 if (!find_unpushed_submodules(new_sha1, remotes_name, &needs_pushing))
622 return 1;
623
624 for (i = 0; i < needs_pushing.nr; i++) {
625 const char *path = needs_pushing.items[i].string;
626 fprintf(stderr, "Pushing submodule '%s'\n", path);
627 if (!push_submodule(path)) {
628 fprintf(stderr, "Unable to push submodule '%s'\n", path);
629 ret = 0;
630 }
631 }
632
633 string_list_clear(&needs_pushing, 0);
634
635 return ret;
636}
637
c16c3e40
JL
638static int is_submodule_commit_present(const char *path, unsigned char sha1[20])
639{
640 int is_present = 0;
641 if (!add_submodule_odb(path) && lookup_commit_reference(sha1)) {
642 /* Even if the submodule is checked out and the commit is
643 * present, make sure it is reachable from a ref. */
d3180279 644 struct child_process cp = CHILD_PROCESS_INIT;
c16c3e40
JL
645 const char *argv[] = {"rev-list", "-n", "1", NULL, "--not", "--all", NULL};
646 struct strbuf buf = STRBUF_INIT;
647
648 argv[3] = sha1_to_hex(sha1);
c16c3e40 649 cp.argv = argv;
c12e8656 650 prepare_submodule_repo_env(&cp.env_array);
c16c3e40
JL
651 cp.git_cmd = 1;
652 cp.no_stdin = 1;
c16c3e40 653 cp.dir = path;
1d4974c9 654 if (!capture_command(&cp, &buf, 1024) && !buf.len)
c16c3e40
JL
655 is_present = 1;
656
c16c3e40
JL
657 strbuf_release(&buf);
658 }
659 return is_present;
660}
661
88a21979
JL
662static void submodule_collect_changed_cb(struct diff_queue_struct *q,
663 struct diff_options *options,
664 void *data)
665{
666 int i;
667 for (i = 0; i < q->nr; i++) {
668 struct diff_filepair *p = q->queue[i];
669 if (!S_ISGITLINK(p->two->mode))
670 continue;
671
672 if (S_ISGITLINK(p->one->mode)) {
673 /* NEEDSWORK: We should honor the name configured in
674 * the .gitmodules file of the commit we are examining
675 * here to be able to correctly follow submodules
676 * being moved around. */
677 struct string_list_item *path;
678 path = unsorted_string_list_lookup(&changed_submodule_paths, p->two->path);
a0d12c44 679 if (!path && !is_submodule_commit_present(p->two->path, p->two->oid.hash))
88a21979
JL
680 string_list_append(&changed_submodule_paths, xstrdup(p->two->path));
681 } else {
682 /* Submodule is new or was moved here */
683 /* NEEDSWORK: When the .git directories of submodules
684 * live inside the superprojects .git directory some
685 * day we should fetch new submodules directly into
686 * that location too when config or options request
687 * that so they can be checked out from there. */
688 continue;
689 }
690 }
691}
692
7290ef58 693static int add_sha1_to_array(const char *ref, const struct object_id *oid,
6859de45
JK
694 int flags, void *data)
695{
7290ef58 696 sha1_array_append(data, oid->hash);
6859de45
JK
697 return 0;
698}
699
88a21979 700void check_for_new_submodule_commits(unsigned char new_sha1[20])
6859de45
JK
701{
702 if (!initialized_fetch_ref_tips) {
703 for_each_ref(add_sha1_to_array, &ref_tips_before_fetch);
704 initialized_fetch_ref_tips = 1;
705 }
706
707 sha1_array_append(&ref_tips_after_fetch, new_sha1);
708}
709
16ddcd40 710static int add_sha1_to_argv(const unsigned char sha1[20], void *data)
6859de45 711{
c1189cae 712 argv_array_push(data, sha1_to_hex(sha1));
16ddcd40 713 return 0;
6859de45
JK
714}
715
716static void calculate_changed_submodule_paths(void)
88a21979
JL
717{
718 struct rev_info rev;
719 struct commit *commit;
c1189cae 720 struct argv_array argv = ARGV_ARRAY_INIT;
88a21979 721
18322bad 722 /* No need to check if there are no submodules configured */
851e18c3 723 if (!submodule_from_path(NULL, NULL))
18322bad
JL
724 return;
725
88a21979 726 init_revisions(&rev, NULL);
c1189cae 727 argv_array_push(&argv, "--"); /* argv[0] program name */
6859de45
JK
728 sha1_array_for_each_unique(&ref_tips_after_fetch,
729 add_sha1_to_argv, &argv);
c1189cae 730 argv_array_push(&argv, "--not");
6859de45
JK
731 sha1_array_for_each_unique(&ref_tips_before_fetch,
732 add_sha1_to_argv, &argv);
733 setup_revisions(argv.argc, argv.argv, &rev, NULL);
88a21979
JL
734 if (prepare_revision_walk(&rev))
735 die("revision walk setup failed");
736
737 /*
738 * Collect all submodules (whether checked out or not) for which new
739 * commits have been recorded upstream in "changed_submodule_paths".
740 */
741 while ((commit = get_revision(&rev))) {
742 struct commit_list *parent = commit->parents;
743 while (parent) {
744 struct diff_options diff_opts;
745 diff_setup(&diff_opts);
ea2d325b 746 DIFF_OPT_SET(&diff_opts, RECURSIVE);
88a21979
JL
747 diff_opts.output_format |= DIFF_FORMAT_CALLBACK;
748 diff_opts.format_callback = submodule_collect_changed_cb;
28452655 749 diff_setup_done(&diff_opts);
ed1c9977 750 diff_tree_sha1(parent->item->object.oid.hash, commit->object.oid.hash, "", &diff_opts);
88a21979
JL
751 diffcore_std(&diff_opts);
752 diff_flush(&diff_opts);
753 parent = parent->next;
754 }
755 }
6859de45 756
c1189cae 757 argv_array_clear(&argv);
6859de45
JK
758 sha1_array_clear(&ref_tips_before_fetch);
759 sha1_array_clear(&ref_tips_after_fetch);
760 initialized_fetch_ref_tips = 0;
88a21979
JL
761}
762
fe85ee6e
SB
763struct submodule_parallel_fetch {
764 int count;
765 struct argv_array args;
766 const char *work_tree;
767 const char *prefix;
768 int command_line_option;
769 int quiet;
770 int result;
771};
772#define SPF_INIT {0, ARGV_ARRAY_INIT, NULL, NULL, 0, 0, 0}
773
774static int get_next_submodule(struct child_process *cp,
775 struct strbuf *err, void *data, void **task_cb)
7dce19d3 776{
fe85ee6e
SB
777 int ret = 0;
778 struct submodule_parallel_fetch *spf = data;
6859de45 779
fe85ee6e 780 for (; spf->count < active_nr; spf->count++) {
7dce19d3
JL
781 struct strbuf submodule_path = STRBUF_INIT;
782 struct strbuf submodule_git_dir = STRBUF_INIT;
783 struct strbuf submodule_prefix = STRBUF_INIT;
fe85ee6e 784 const struct cache_entry *ce = active_cache[spf->count];
851e18c3
HV
785 const char *git_dir, *default_argv;
786 const struct submodule *submodule;
7dce19d3
JL
787
788 if (!S_ISGITLINK(ce->ce_mode))
789 continue;
790
851e18c3
HV
791 submodule = submodule_from_path(null_sha1, ce->name);
792 if (!submodule)
793 submodule = submodule_from_name(null_sha1, ce->name);
7dce19d3 794
88a21979 795 default_argv = "yes";
fe85ee6e 796 if (spf->command_line_option == RECURSE_SUBMODULES_DEFAULT) {
851e18c3
HV
797 if (submodule &&
798 submodule->fetch_recurse !=
799 RECURSE_SUBMODULES_NONE) {
800 if (submodule->fetch_recurse ==
801 RECURSE_SUBMODULES_OFF)
c1a3c364 802 continue;
851e18c3
HV
803 if (submodule->fetch_recurse ==
804 RECURSE_SUBMODULES_ON_DEMAND) {
bf42b384
JL
805 if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
806 continue;
807 default_argv = "on-demand";
808 }
c1a3c364 809 } else {
d4e98b58
JL
810 if ((config_fetch_recurse_submodules == RECURSE_SUBMODULES_OFF) ||
811 gitmodules_is_unmerged)
c1a3c364 812 continue;
88a21979
JL
813 if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND) {
814 if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
815 continue;
816 default_argv = "on-demand";
817 }
c1a3c364 818 }
fe85ee6e 819 } else if (spf->command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {
8f0700dd
JL
820 if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
821 continue;
822 default_argv = "on-demand";
be254a0e
JL
823 }
824
fe85ee6e 825 strbuf_addf(&submodule_path, "%s/%s", spf->work_tree, ce->name);
7dce19d3 826 strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);
fe85ee6e 827 strbuf_addf(&submodule_prefix, "%s%s/", spf->prefix, ce->name);
13d6ec91 828 git_dir = read_gitfile(submodule_git_dir.buf);
7dce19d3
JL
829 if (!git_dir)
830 git_dir = submodule_git_dir.buf;
831 if (is_directory(git_dir)) {
fe85ee6e
SB
832 child_process_init(cp);
833 cp->dir = strbuf_detach(&submodule_path, NULL);
c12e8656 834 prepare_submodule_repo_env(&cp->env_array);
fe85ee6e
SB
835 cp->git_cmd = 1;
836 if (!spf->quiet)
837 strbuf_addf(err, "Fetching submodule %s%s\n",
838 spf->prefix, ce->name);
839 argv_array_init(&cp->args);
840 argv_array_pushv(&cp->args, spf->args.argv);
841 argv_array_push(&cp->args, default_argv);
842 argv_array_push(&cp->args, "--submodule-prefix");
843 argv_array_push(&cp->args, submodule_prefix.buf);
844 ret = 1;
7dce19d3
JL
845 }
846 strbuf_release(&submodule_path);
847 strbuf_release(&submodule_git_dir);
848 strbuf_release(&submodule_prefix);
fe85ee6e
SB
849 if (ret) {
850 spf->count++;
851 return 1;
852 }
7dce19d3 853 }
fe85ee6e
SB
854 return 0;
855}
856
2a73b3da 857static int fetch_start_failure(struct strbuf *err,
fe85ee6e
SB
858 void *cb, void *task_cb)
859{
860 struct submodule_parallel_fetch *spf = cb;
861
862 spf->result = 1;
863
864 return 0;
865}
866
2a73b3da
SB
867static int fetch_finish(int retvalue, struct strbuf *err,
868 void *cb, void *task_cb)
fe85ee6e
SB
869{
870 struct submodule_parallel_fetch *spf = cb;
871
872 if (retvalue)
873 spf->result = 1;
874
875 return 0;
876}
877
878int fetch_populated_submodules(const struct argv_array *options,
879 const char *prefix, int command_line_option,
62104ba1 880 int quiet, int max_parallel_jobs)
fe85ee6e
SB
881{
882 int i;
fe85ee6e
SB
883 struct submodule_parallel_fetch spf = SPF_INIT;
884
885 spf.work_tree = get_git_work_tree();
886 spf.command_line_option = command_line_option;
887 spf.quiet = quiet;
888 spf.prefix = prefix;
889
890 if (!spf.work_tree)
891 goto out;
892
893 if (read_cache() < 0)
894 die("index file corrupt");
895
896 argv_array_push(&spf.args, "fetch");
897 for (i = 0; i < options->argc; i++)
898 argv_array_push(&spf.args, options->argv[i]);
899 argv_array_push(&spf.args, "--recurse-submodules-default");
900 /* default value, "--submodule-prefix" and its value are added later */
901
a028a193
SB
902 if (max_parallel_jobs < 0)
903 max_parallel_jobs = parallel_jobs;
904
fe85ee6e
SB
905 calculate_changed_submodule_paths();
906 run_processes_parallel(max_parallel_jobs,
907 get_next_submodule,
908 fetch_start_failure,
909 fetch_finish,
910 &spf);
911
912 argv_array_clear(&spf.args);
88a21979
JL
913out:
914 string_list_clear(&changed_submodule_paths, 1);
fe85ee6e 915 return spf.result;
7dce19d3
JL
916}
917
3bfc4504 918unsigned is_submodule_modified(const char *path, int ignore_untracked)
ee6fc514 919{
c7e1a736 920 ssize_t len;
d3180279 921 struct child_process cp = CHILD_PROCESS_INIT;
ee6fc514
JL
922 const char *argv[] = {
923 "status",
924 "--porcelain",
925 NULL,
3bfc4504 926 NULL,
ee6fc514 927 };
ee6fc514 928 struct strbuf buf = STRBUF_INIT;
c7e1a736
JL
929 unsigned dirty_submodule = 0;
930 const char *line, *next_line;
eee49b6c 931 const char *git_dir;
ee6fc514 932
eee49b6c 933 strbuf_addf(&buf, "%s/.git", path);
13d6ec91 934 git_dir = read_gitfile(buf.buf);
eee49b6c
JL
935 if (!git_dir)
936 git_dir = buf.buf;
937 if (!is_directory(git_dir)) {
ee6fc514
JL
938 strbuf_release(&buf);
939 /* The submodule is not checked out, so it is not modified */
940 return 0;
941
942 }
943 strbuf_reset(&buf);
944
3bfc4504
JL
945 if (ignore_untracked)
946 argv[2] = "-uno";
947
ee6fc514 948 cp.argv = argv;
c12e8656 949 prepare_submodule_repo_env(&cp.env_array);
ee6fc514
JL
950 cp.git_cmd = 1;
951 cp.no_stdin = 1;
952 cp.out = -1;
eee49b6c 953 cp.dir = path;
ee6fc514 954 if (start_command(&cp))
6a5cedac 955 die("Could not run 'git status --porcelain' in submodule %s", path);
ee6fc514
JL
956
957 len = strbuf_read(&buf, cp.out, 1024);
c7e1a736
JL
958 line = buf.buf;
959 while (len > 2) {
960 if ((line[0] == '?') && (line[1] == '?')) {
961 dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
962 if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
963 break;
964 } else {
965 dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
3bfc4504
JL
966 if (ignore_untracked ||
967 (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED))
c7e1a736
JL
968 break;
969 }
970 next_line = strchr(line, '\n');
971 if (!next_line)
972 break;
973 next_line++;
974 len -= (next_line - line);
975 line = next_line;
976 }
ee6fc514
JL
977 close(cp.out);
978
979 if (finish_command(&cp))
6a5cedac 980 die("'git status --porcelain' failed in submodule %s", path);
ee6fc514 981
ee6fc514 982 strbuf_release(&buf);
c7e1a736 983 return dirty_submodule;
ee6fc514 984}
68d03e4a 985
293ab15e
JL
986int submodule_uses_gitfile(const char *path)
987{
d3180279 988 struct child_process cp = CHILD_PROCESS_INIT;
293ab15e
JL
989 const char *argv[] = {
990 "submodule",
991 "foreach",
992 "--quiet",
993 "--recursive",
994 "test -f .git",
995 NULL,
996 };
997 struct strbuf buf = STRBUF_INIT;
998 const char *git_dir;
999
1000 strbuf_addf(&buf, "%s/.git", path);
1001 git_dir = read_gitfile(buf.buf);
1002 if (!git_dir) {
1003 strbuf_release(&buf);
1004 return 0;
1005 }
1006 strbuf_release(&buf);
1007
1008 /* Now test that all nested submodules use a gitfile too */
293ab15e 1009 cp.argv = argv;
c12e8656 1010 prepare_submodule_repo_env(&cp.env_array);
293ab15e
JL
1011 cp.git_cmd = 1;
1012 cp.no_stdin = 1;
1013 cp.no_stderr = 1;
1014 cp.no_stdout = 1;
1015 cp.dir = path;
1016 if (run_command(&cp))
1017 return 0;
1018
1019 return 1;
1020}
1021
1022int ok_to_remove_submodule(const char *path)
1023{
293ab15e 1024 ssize_t len;
d3180279 1025 struct child_process cp = CHILD_PROCESS_INIT;
293ab15e
JL
1026 struct strbuf buf = STRBUF_INIT;
1027 int ok_to_remove = 1;
1028
dbe44faa 1029 if (!file_exists(path) || is_empty_dir(path))
293ab15e
JL
1030 return 1;
1031
1032 if (!submodule_uses_gitfile(path))
1033 return 0;
1034
5a1c824f
SB
1035 argv_array_pushl(&cp.args, "status", "--porcelain", "-u",
1036 "--ignore-submodules=none", NULL);
c12e8656 1037 prepare_submodule_repo_env(&cp.env_array);
293ab15e
JL
1038 cp.git_cmd = 1;
1039 cp.no_stdin = 1;
1040 cp.out = -1;
1041 cp.dir = path;
1042 if (start_command(&cp))
5a1c824f 1043 die(_("could not run 'git status --porcelain -u --ignore-submodules=none' in submodule %s"), path);
293ab15e
JL
1044
1045 len = strbuf_read(&buf, cp.out, 1024);
1046 if (len > 2)
1047 ok_to_remove = 0;
1048 close(cp.out);
1049
1050 if (finish_command(&cp))
5a1c824f 1051 die(_("'git status --porcelain -u --ignore-submodules=none' failed in submodule %s"), path);
293ab15e
JL
1052
1053 strbuf_release(&buf);
1054 return ok_to_remove;
1055}
1056
68d03e4a
HV
1057static int find_first_merges(struct object_array *result, const char *path,
1058 struct commit *a, struct commit *b)
1059{
1060 int i, j;
3826902d 1061 struct object_array merges = OBJECT_ARRAY_INIT;
68d03e4a
HV
1062 struct commit *commit;
1063 int contains_another;
1064
1065 char merged_revision[42];
1066 const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
1067 "--all", merged_revision, NULL };
1068 struct rev_info revs;
1069 struct setup_revision_opt rev_opts;
1070
68d03e4a
HV
1071 memset(result, 0, sizeof(struct object_array));
1072 memset(&rev_opts, 0, sizeof(rev_opts));
1073
1074 /* get all revisions that merge commit a */
1075 snprintf(merged_revision, sizeof(merged_revision), "^%s",
f2fd0760 1076 oid_to_hex(&a->object.oid));
68d03e4a
HV
1077 init_revisions(&revs, NULL);
1078 rev_opts.submodule = path;
94c0cc8f 1079 setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);
68d03e4a
HV
1080
1081 /* save all revisions from the above list that contain b */
1082 if (prepare_revision_walk(&revs))
1083 die("revision walk setup failed");
1084 while ((commit = get_revision(&revs)) != NULL) {
1085 struct object *o = &(commit->object);
a20efee9 1086 if (in_merge_bases(b, commit))
68d03e4a
HV
1087 add_object_array(o, NULL, &merges);
1088 }
bcc0a3ea 1089 reset_revision_walk();
68d03e4a
HV
1090
1091 /* Now we've got all merges that contain a and b. Prune all
1092 * merges that contain another found merge and save them in
1093 * result.
1094 */
1095 for (i = 0; i < merges.nr; i++) {
1096 struct commit *m1 = (struct commit *) merges.objects[i].item;
1097
1098 contains_another = 0;
1099 for (j = 0; j < merges.nr; j++) {
1100 struct commit *m2 = (struct commit *) merges.objects[j].item;
a20efee9 1101 if (i != j && in_merge_bases(m2, m1)) {
68d03e4a
HV
1102 contains_another = 1;
1103 break;
1104 }
1105 }
1106
1107 if (!contains_another)
5de0c015 1108 add_object_array(merges.objects[i].item, NULL, result);
68d03e4a
HV
1109 }
1110
1111 free(merges.objects);
1112 return result->nr;
1113}
1114
1115static void print_commit(struct commit *commit)
1116{
1117 struct strbuf sb = STRBUF_INIT;
1118 struct pretty_print_context ctx = {0};
a5481a6c 1119 ctx.date_mode.type = DATE_NORMAL;
68d03e4a
HV
1120 format_commit_message(commit, " %h: %m %s", &sb, &ctx);
1121 fprintf(stderr, "%s\n", sb.buf);
1122 strbuf_release(&sb);
1123}
1124
1125#define MERGE_WARNING(path, msg) \
1126 warning("Failed to merge submodule %s (%s)", path, msg);
1127
1128int merge_submodule(unsigned char result[20], const char *path,
1129 const unsigned char base[20], const unsigned char a[20],
80988783 1130 const unsigned char b[20], int search)
68d03e4a
HV
1131{
1132 struct commit *commit_base, *commit_a, *commit_b;
1133 int parent_count;
1134 struct object_array merges;
1135
1136 int i;
1137
1138 /* store a in result in case we fail */
1139 hashcpy(result, a);
1140
1141 /* we can not handle deletion conflicts */
1142 if (is_null_sha1(base))
1143 return 0;
1144 if (is_null_sha1(a))
1145 return 0;
1146 if (is_null_sha1(b))
1147 return 0;
1148
1149 if (add_submodule_odb(path)) {
1150 MERGE_WARNING(path, "not checked out");
1151 return 0;
1152 }
1153
1154 if (!(commit_base = lookup_commit_reference(base)) ||
1155 !(commit_a = lookup_commit_reference(a)) ||
1156 !(commit_b = lookup_commit_reference(b))) {
1157 MERGE_WARNING(path, "commits not present");
1158 return 0;
1159 }
1160
1161 /* check whether both changes are forward */
a20efee9
JH
1162 if (!in_merge_bases(commit_base, commit_a) ||
1163 !in_merge_bases(commit_base, commit_b)) {
68d03e4a
HV
1164 MERGE_WARNING(path, "commits don't follow merge-base");
1165 return 0;
1166 }
1167
1168 /* Case #1: a is contained in b or vice versa */
a20efee9 1169 if (in_merge_bases(commit_a, commit_b)) {
68d03e4a
HV
1170 hashcpy(result, b);
1171 return 1;
1172 }
a20efee9 1173 if (in_merge_bases(commit_b, commit_a)) {
68d03e4a
HV
1174 hashcpy(result, a);
1175 return 1;
1176 }
1177
1178 /*
1179 * Case #2: There are one or more merges that contain a and b in
1180 * the submodule. If there is only one, then present it as a
1181 * suggestion to the user, but leave it marked unmerged so the
1182 * user needs to confirm the resolution.
1183 */
1184
80988783
BK
1185 /* Skip the search if makes no sense to the calling context. */
1186 if (!search)
1187 return 0;
1188
68d03e4a
HV
1189 /* find commit which merges them */
1190 parent_count = find_first_merges(&merges, path, commit_a, commit_b);
1191 switch (parent_count) {
1192 case 0:
1193 MERGE_WARNING(path, "merge following commits not found");
1194 break;
1195
1196 case 1:
1197 MERGE_WARNING(path, "not fast-forward");
1198 fprintf(stderr, "Found a possible merge resolution "
1199 "for the submodule:\n");
1200 print_commit((struct commit *) merges.objects[0].item);
1201 fprintf(stderr,
1202 "If this is correct simply add it to the index "
1203 "for example\n"
1204 "by using:\n\n"
1205 " git update-index --cacheinfo 160000 %s \"%s\"\n\n"
1206 "which will accept this suggestion.\n",
f2fd0760 1207 oid_to_hex(&merges.objects[0].item->oid), path);
68d03e4a
HV
1208 break;
1209
1210 default:
1211 MERGE_WARNING(path, "multiple merges found");
1212 for (i = 0; i < merges.nr; i++)
1213 print_commit((struct commit *) merges.objects[i].item);
1214 }
1215
1216 free(merges.objects);
1217 return 0;
1218}
a88c915d 1219
a028a193
SB
1220int parallel_submodules(void)
1221{
1222 return parallel_jobs;
1223}
e059388f 1224
4638728c
JK
1225void prepare_submodule_repo_env(struct argv_array *out)
1226{
1227 const char * const *var;
1228
1229 for (var = local_repo_env; *var; var++) {
89044baa 1230 if (strcmp(*var, CONFIG_DATA_ENVIRONMENT))
4638728c 1231 argv_array_push(out, *var);
4638728c 1232 }
10f5c526 1233 argv_array_push(out, "GIT_DIR=.git");
4638728c 1234}
f6f85861
SB
1235
1236/*
1237 * Embeds a single submodules git directory into the superprojects git dir,
1238 * non recursively.
1239 */
1240static void relocate_single_git_dir_into_superproject(const char *prefix,
1241 const char *path)
1242{
1243 char *old_git_dir = NULL, *real_old_git_dir = NULL, *real_new_git_dir = NULL;
1244 const char *new_git_dir;
1245 const struct submodule *sub;
1246
1247 if (submodule_uses_worktrees(path))
1248 die(_("relocate_gitdir for submodule '%s' with "
1249 "more than one worktree not supported"), path);
1250
1251 old_git_dir = xstrfmt("%s/.git", path);
1252 if (read_gitfile(old_git_dir))
1253 /* If it is an actual gitfile, it doesn't need migration. */
1254 return;
1255
1256 real_old_git_dir = xstrdup(real_path(old_git_dir));
1257
1258 sub = submodule_from_path(null_sha1, path);
1259 if (!sub)
1260 die(_("could not lookup name for submodule '%s'"), path);
1261
1262 new_git_dir = git_path("modules/%s", sub->name);
1263 if (safe_create_leading_directories_const(new_git_dir) < 0)
1264 die(_("could not create directory '%s'"), new_git_dir);
1265 real_new_git_dir = xstrdup(real_path(new_git_dir));
1266
1267 if (!prefix)
1268 prefix = get_super_prefix();
1269
1270 fprintf(stderr, _("Migrating git directory of '%s%s' from\n'%s' to\n'%s'\n"),
1271 prefix ? prefix : "", path,
1272 real_old_git_dir, real_new_git_dir);
1273
1274 relocate_gitdir(path, real_old_git_dir, real_new_git_dir);
1275
1276 free(old_git_dir);
1277 free(real_old_git_dir);
1278 free(real_new_git_dir);
1279}
1280
1281/*
1282 * Migrate the git directory of the submodule given by path from
1283 * having its git directory within the working tree to the git dir nested
1284 * in its superprojects git dir under modules/.
1285 */
1286void absorb_git_dir_into_superproject(const char *prefix,
1287 const char *path,
1288 unsigned flags)
1289{
1290 const char *sub_git_dir, *v;
1291 char *real_sub_git_dir = NULL, *real_common_git_dir = NULL;
1292 struct strbuf gitdir = STRBUF_INIT;
1293
1294 strbuf_addf(&gitdir, "%s/.git", path);
1295 sub_git_dir = resolve_gitdir(gitdir.buf);
1296
1297 /* Not populated? */
1298 if (!sub_git_dir)
1299 goto out;
1300
1301 /* Is it already absorbed into the superprojects git dir? */
1302 real_sub_git_dir = xstrdup(real_path(sub_git_dir));
1303 real_common_git_dir = xstrdup(real_path(get_git_common_dir()));
1304 if (!skip_prefix(real_sub_git_dir, real_common_git_dir, &v))
1305 relocate_single_git_dir_into_superproject(prefix, path);
1306
1307 if (flags & ABSORB_GITDIR_RECURSE_SUBMODULES) {
1308 struct child_process cp = CHILD_PROCESS_INIT;
1309 struct strbuf sb = STRBUF_INIT;
1310
1311 if (flags & ~ABSORB_GITDIR_RECURSE_SUBMODULES)
1312 die("BUG: we don't know how to pass the flags down?");
1313
1314 if (get_super_prefix())
1315 strbuf_addstr(&sb, get_super_prefix());
1316 strbuf_addstr(&sb, path);
1317 strbuf_addch(&sb, '/');
1318
1319 cp.dir = path;
1320 cp.git_cmd = 1;
1321 cp.no_stdin = 1;
1322 argv_array_pushl(&cp.args, "--super-prefix", sb.buf,
1323 "submodule--helper",
1324 "absorb-git-dirs", NULL);
1325 prepare_submodule_repo_env(&cp.env_array);
1326 if (run_command(&cp))
1327 die(_("could not recurse into submodule '%s'"), path);
1328
1329 strbuf_release(&sb);
1330 }
1331
1332out:
1333 strbuf_release(&gitdir);
1334 free(real_sub_git_dir);
1335 free(real_common_git_dir);
1336}