submodule-config: move submodule-config functions to submodule-config.c
[git/git.git] / submodule-config.c
CommitLineData
959b5455 1#include "cache.h"
bf12fcdf 2#include "repository.h"
b2141fc1 3#include "config.h"
959b5455
HV
4#include "submodule-config.h"
5#include "submodule.h"
6#include "strbuf.h"
886dc154 7#include "parse-options.h"
959b5455
HV
8
9/*
10 * submodule cache lookup structure
11 * There is one shared set of 'struct submodule' entries which can be
12 * looked up by their sha1 blob id of the .gitmodule file and either
13 * using path or name as key.
14 * for_path stores submodule entries with path as key
15 * for_name stores submodule entries with name as key
16 */
17struct submodule_cache {
18 struct hashmap for_path;
19 struct hashmap for_name;
bf12fcdf 20 unsigned initialized:1;
959b5455
HV
21};
22
23/*
24 * thin wrapper struct needed to insert 'struct submodule' entries to
25 * the hashmap
26 */
27struct submodule_entry {
28 struct hashmap_entry ent;
29 struct submodule *config;
30};
31
32enum lookup_type {
33 lookup_name,
34 lookup_path
35};
36
7663cdc8
SB
37static int config_path_cmp(const void *unused_cmp_data,
38 const struct submodule_entry *a,
959b5455 39 const struct submodule_entry *b,
7663cdc8 40 const void *unused_keydata)
959b5455
HV
41{
42 return strcmp(a->config->path, b->config->path) ||
43 hashcmp(a->config->gitmodules_sha1, b->config->gitmodules_sha1);
44}
45
7663cdc8
SB
46static int config_name_cmp(const void *unused_cmp_data,
47 const struct submodule_entry *a,
959b5455 48 const struct submodule_entry *b,
7663cdc8 49 const void *unused_keydata)
959b5455
HV
50{
51 return strcmp(a->config->name, b->config->name) ||
52 hashcmp(a->config->gitmodules_sha1, b->config->gitmodules_sha1);
53}
54
bf12fcdf
BW
55static struct submodule_cache *submodule_cache_alloc(void)
56{
57 return xcalloc(1, sizeof(struct submodule_cache));
58}
59
60static void submodule_cache_init(struct submodule_cache *cache)
959b5455 61{
7663cdc8
SB
62 hashmap_init(&cache->for_path, (hashmap_cmp_fn) config_path_cmp, NULL, 0);
63 hashmap_init(&cache->for_name, (hashmap_cmp_fn) config_name_cmp, NULL, 0);
bf12fcdf 64 cache->initialized = 1;
959b5455
HV
65}
66
67static void free_one_config(struct submodule_entry *entry)
68{
69 free((void *) entry->config->path);
70 free((void *) entry->config->name);
b5944f34 71 free((void *) entry->config->branch);
ea2fa5a3 72 free((void *) entry->config->update_strategy.command);
959b5455
HV
73 free(entry->config);
74}
75
bf12fcdf 76static void submodule_cache_clear(struct submodule_cache *cache)
959b5455
HV
77{
78 struct hashmap_iter iter;
79 struct submodule_entry *entry;
80
bf12fcdf
BW
81 if (!cache->initialized)
82 return;
83
959b5455
HV
84 /*
85 * We iterate over the name hash here to be symmetric with the
86 * allocation of struct submodule entries. Each is allocated by
87 * their .gitmodule blob sha1 and submodule name.
88 */
89 hashmap_iter_init(&cache->for_name, &iter);
90 while ((entry = hashmap_iter_next(&iter)))
91 free_one_config(entry);
92
93 hashmap_free(&cache->for_path, 1);
94 hashmap_free(&cache->for_name, 1);
bf12fcdf
BW
95 cache->initialized = 0;
96}
97
98void submodule_cache_free(struct submodule_cache *cache)
99{
100 submodule_cache_clear(cache);
101 free(cache);
959b5455
HV
102}
103
104static unsigned int hash_sha1_string(const unsigned char *sha1,
105 const char *string)
106{
107 return memhash(sha1, 20) + strhash(string);
108}
109
110static void cache_put_path(struct submodule_cache *cache,
111 struct submodule *submodule)
112{
113 unsigned int hash = hash_sha1_string(submodule->gitmodules_sha1,
114 submodule->path);
115 struct submodule_entry *e = xmalloc(sizeof(*e));
116 hashmap_entry_init(e, hash);
117 e->config = submodule;
118 hashmap_put(&cache->for_path, e);
119}
120
121static void cache_remove_path(struct submodule_cache *cache,
122 struct submodule *submodule)
123{
124 unsigned int hash = hash_sha1_string(submodule->gitmodules_sha1,
125 submodule->path);
126 struct submodule_entry e;
127 struct submodule_entry *removed;
128 hashmap_entry_init(&e, hash);
129 e.config = submodule;
130 removed = hashmap_remove(&cache->for_path, &e, NULL);
131 free(removed);
132}
133
134static void cache_add(struct submodule_cache *cache,
135 struct submodule *submodule)
136{
137 unsigned int hash = hash_sha1_string(submodule->gitmodules_sha1,
138 submodule->name);
139 struct submodule_entry *e = xmalloc(sizeof(*e));
140 hashmap_entry_init(e, hash);
141 e->config = submodule;
142 hashmap_add(&cache->for_name, e);
143}
144
145static const struct submodule *cache_lookup_path(struct submodule_cache *cache,
146 const unsigned char *gitmodules_sha1, const char *path)
147{
148 struct submodule_entry *entry;
149 unsigned int hash = hash_sha1_string(gitmodules_sha1, path);
150 struct submodule_entry key;
151 struct submodule key_config;
152
153 hashcpy(key_config.gitmodules_sha1, gitmodules_sha1);
154 key_config.path = path;
155
156 hashmap_entry_init(&key, hash);
157 key.config = &key_config;
158
159 entry = hashmap_get(&cache->for_path, &key, NULL);
160 if (entry)
161 return entry->config;
162 return NULL;
163}
164
165static struct submodule *cache_lookup_name(struct submodule_cache *cache,
166 const unsigned char *gitmodules_sha1, const char *name)
167{
168 struct submodule_entry *entry;
169 unsigned int hash = hash_sha1_string(gitmodules_sha1, name);
170 struct submodule_entry key;
171 struct submodule key_config;
172
173 hashcpy(key_config.gitmodules_sha1, gitmodules_sha1);
174 key_config.name = name;
175
176 hashmap_entry_init(&key, hash);
177 key.config = &key_config;
178
179 entry = hashmap_get(&cache->for_name, &key, NULL);
180 if (entry)
181 return entry->config;
182 return NULL;
183}
184
185static int name_and_item_from_var(const char *var, struct strbuf *name,
186 struct strbuf *item)
187{
188 const char *subsection, *key;
189 int subsection_len, parse;
190 parse = parse_config_key(var, "submodule", &subsection,
191 &subsection_len, &key);
192 if (parse < 0 || !subsection)
193 return 0;
194
195 strbuf_add(name, subsection, subsection_len);
196 strbuf_addstr(item, key);
197
198 return 1;
199}
200
201static struct submodule *lookup_or_create_by_name(struct submodule_cache *cache,
202 const unsigned char *gitmodules_sha1, const char *name)
203{
204 struct submodule *submodule;
205 struct strbuf name_buf = STRBUF_INIT;
206
207 submodule = cache_lookup_name(cache, gitmodules_sha1, name);
208 if (submodule)
209 return submodule;
210
211 submodule = xmalloc(sizeof(*submodule));
212
213 strbuf_addstr(&name_buf, name);
214 submodule->name = strbuf_detach(&name_buf, NULL);
215
216 submodule->path = NULL;
217 submodule->url = NULL;
ea2fa5a3
SB
218 submodule->update_strategy.type = SM_UPDATE_UNSPECIFIED;
219 submodule->update_strategy.command = NULL;
959b5455
HV
220 submodule->fetch_recurse = RECURSE_SUBMODULES_NONE;
221 submodule->ignore = NULL;
b5944f34 222 submodule->branch = NULL;
37f52e93 223 submodule->recommend_shallow = -1;
959b5455
HV
224
225 hashcpy(submodule->gitmodules_sha1, gitmodules_sha1);
226
227 cache_add(cache, submodule);
228
229 return submodule;
230}
231
027771fc
HV
232static int parse_fetch_recurse(const char *opt, const char *arg,
233 int die_on_error)
234{
235 switch (git_config_maybe_bool(opt, arg)) {
236 case 1:
237 return RECURSE_SUBMODULES_ON;
238 case 0:
239 return RECURSE_SUBMODULES_OFF;
240 default:
241 if (!strcmp(arg, "on-demand"))
242 return RECURSE_SUBMODULES_ON_DEMAND;
243
244 if (die_on_error)
245 die("bad %s argument: %s", opt, arg);
246 else
247 return RECURSE_SUBMODULES_ERROR;
248 }
249}
250
f20e7c1e
BW
251int parse_submodule_fetchjobs(const char *var, const char *value)
252{
253 int fetchjobs = git_config_int(var, value);
254 if (fetchjobs < 0)
255 die(_("negative values not allowed for submodule.fetchjobs"));
256 return fetchjobs;
257}
258
027771fc
HV
259int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg)
260{
261 return parse_fetch_recurse(opt, arg, 1);
262}
263
886dc154
SB
264int option_fetch_parse_recurse_submodules(const struct option *opt,
265 const char *arg, int unset)
266{
267 int *v;
268
269 if (!opt->value)
270 return -1;
271
272 v = opt->value;
273
274 if (unset) {
275 *v = RECURSE_SUBMODULES_OFF;
276 } else {
277 if (arg)
278 *v = parse_fetch_recurse_submodules_arg(opt->long_name, arg);
279 else
280 *v = RECURSE_SUBMODULES_ON;
281 }
282 return 0;
283}
284
d601fd09
SB
285static int parse_update_recurse(const char *opt, const char *arg,
286 int die_on_error)
287{
288 switch (git_config_maybe_bool(opt, arg)) {
289 case 1:
290 return RECURSE_SUBMODULES_ON;
291 case 0:
292 return RECURSE_SUBMODULES_OFF;
293 default:
294 if (die_on_error)
295 die("bad %s argument: %s", opt, arg);
296 return RECURSE_SUBMODULES_ERROR;
297 }
298}
299
300int parse_update_recurse_submodules_arg(const char *opt, const char *arg)
301{
302 return parse_update_recurse(opt, arg, 1);
303}
304
b33a15b0
MC
305static int parse_push_recurse(const char *opt, const char *arg,
306 int die_on_error)
307{
308 switch (git_config_maybe_bool(opt, arg)) {
309 case 1:
310 /* There's no simple "on" value when pushing */
311 if (die_on_error)
312 die("bad %s argument: %s", opt, arg);
313 else
314 return RECURSE_SUBMODULES_ERROR;
315 case 0:
316 return RECURSE_SUBMODULES_OFF;
317 default:
318 if (!strcmp(arg, "on-demand"))
319 return RECURSE_SUBMODULES_ON_DEMAND;
320 else if (!strcmp(arg, "check"))
321 return RECURSE_SUBMODULES_CHECK;
6c656c3f
BW
322 else if (!strcmp(arg, "only"))
323 return RECURSE_SUBMODULES_ONLY;
b33a15b0
MC
324 else if (die_on_error)
325 die("bad %s argument: %s", opt, arg);
326 else
327 return RECURSE_SUBMODULES_ERROR;
328 }
329}
330
331int parse_push_recurse_submodules_arg(const char *opt, const char *arg)
332{
333 return parse_push_recurse(opt, arg, 1);
334}
335
73c293bb 336static void warn_multiple_config(const unsigned char *treeish_name,
959b5455
HV
337 const char *name, const char *option)
338{
339 const char *commit_string = "WORKTREE";
73c293bb
SB
340 if (treeish_name)
341 commit_string = sha1_to_hex(treeish_name);
959b5455
HV
342 warning("%s:.gitmodules, multiple configurations found for "
343 "'submodule.%s.%s'. Skipping second one!",
344 commit_string, name, option);
345}
346
347struct parse_config_parameter {
348 struct submodule_cache *cache;
73c293bb 349 const unsigned char *treeish_name;
959b5455
HV
350 const unsigned char *gitmodules_sha1;
351 int overwrite;
352};
353
354static int parse_config(const char *var, const char *value, void *data)
355{
356 struct parse_config_parameter *me = data;
357 struct submodule *submodule;
358 struct strbuf name = STRBUF_INIT, item = STRBUF_INIT;
359 int ret = 0;
360
361 /* this also ensures that we only parse submodule entries */
362 if (!name_and_item_from_var(var, &name, &item))
363 return 0;
364
147875fd
SB
365 submodule = lookup_or_create_by_name(me->cache,
366 me->gitmodules_sha1,
367 name.buf);
959b5455
HV
368
369 if (!strcmp(item.buf, "path")) {
147875fd 370 if (!value)
959b5455 371 ret = config_error_nonbool(var);
f73da110 372 else if (!me->overwrite && submodule->path)
73c293bb 373 warn_multiple_config(me->treeish_name, submodule->name,
959b5455 374 "path");
147875fd
SB
375 else {
376 if (submodule->path)
377 cache_remove_path(me->cache, submodule);
378 free((void *) submodule->path);
379 submodule->path = xstrdup(value);
380 cache_put_path(me->cache, submodule);
959b5455 381 }
959b5455 382 } else if (!strcmp(item.buf, "fetchrecursesubmodules")) {
027771fc
HV
383 /* when parsing worktree configurations we can die early */
384 int die_on_error = is_null_sha1(me->gitmodules_sha1);
959b5455 385 if (!me->overwrite &&
147875fd 386 submodule->fetch_recurse != RECURSE_SUBMODULES_NONE)
73c293bb 387 warn_multiple_config(me->treeish_name, submodule->name,
959b5455 388 "fetchrecursesubmodules");
147875fd
SB
389 else
390 submodule->fetch_recurse = parse_fetch_recurse(
391 var, value,
027771fc 392 die_on_error);
959b5455 393 } else if (!strcmp(item.buf, "ignore")) {
147875fd
SB
394 if (!value)
395 ret = config_error_nonbool(var);
f73da110 396 else if (!me->overwrite && submodule->ignore)
73c293bb 397 warn_multiple_config(me->treeish_name, submodule->name,
959b5455 398 "ignore");
147875fd
SB
399 else if (strcmp(value, "untracked") &&
400 strcmp(value, "dirty") &&
401 strcmp(value, "all") &&
402 strcmp(value, "none"))
959b5455 403 warning("Invalid parameter '%s' for config option "
5ea30489 404 "'submodule.%s.ignore'", value, name.buf);
147875fd
SB
405 else {
406 free((void *) submodule->ignore);
407 submodule->ignore = xstrdup(value);
959b5455 408 }
959b5455 409 } else if (!strcmp(item.buf, "url")) {
959b5455
HV
410 if (!value) {
411 ret = config_error_nonbool(var);
f73da110 412 } else if (!me->overwrite && submodule->url) {
73c293bb 413 warn_multiple_config(me->treeish_name, submodule->name,
959b5455 414 "url");
147875fd
SB
415 } else {
416 free((void *) submodule->url);
417 submodule->url = xstrdup(value);
959b5455 418 }
ea2fa5a3
SB
419 } else if (!strcmp(item.buf, "update")) {
420 if (!value)
421 ret = config_error_nonbool(var);
422 else if (!me->overwrite &&
423 submodule->update_strategy.type != SM_UPDATE_UNSPECIFIED)
73c293bb 424 warn_multiple_config(me->treeish_name, submodule->name,
ea2fa5a3
SB
425 "update");
426 else if (parse_submodule_update_strategy(value,
427 &submodule->update_strategy) < 0)
428 die(_("invalid value for %s"), var);
37f52e93
SB
429 } else if (!strcmp(item.buf, "shallow")) {
430 if (!me->overwrite && submodule->recommend_shallow != -1)
73c293bb 431 warn_multiple_config(me->treeish_name, submodule->name,
37f52e93 432 "shallow");
b5944f34 433 else
37f52e93
SB
434 submodule->recommend_shallow =
435 git_config_bool(var, value);
b5944f34
SB
436 } else if (!strcmp(item.buf, "branch")) {
437 if (!me->overwrite && submodule->branch)
73c293bb 438 warn_multiple_config(me->treeish_name, submodule->name,
b5944f34
SB
439 "branch");
440 else {
441 free((void *)submodule->branch);
442 submodule->branch = xstrdup(value);
37f52e93 443 }
959b5455
HV
444 }
445
959b5455
HV
446 strbuf_release(&name);
447 strbuf_release(&item);
448
449 return ret;
450}
451
1b796ace
BW
452static int gitmodule_oid_from_commit(const struct object_id *treeish_name,
453 struct object_id *gitmodules_oid,
454 struct strbuf *rev)
959b5455 455{
959b5455
HV
456 int ret = 0;
457
cd73de47 458 if (is_null_oid(treeish_name)) {
459 oidclr(gitmodules_oid);
959b5455
HV
460 return 1;
461 }
462
cd73de47 463 strbuf_addf(rev, "%s:.gitmodules", oid_to_hex(treeish_name));
464 if (get_oid(rev->buf, gitmodules_oid) >= 0)
959b5455
HV
465 ret = 1;
466
959b5455
HV
467 return ret;
468}
469
470/* This does a lookup of a submodule configuration by name or by path
471 * (key) with on-demand reading of the appropriate .gitmodules from
472 * revisions.
473 */
474static const struct submodule *config_from(struct submodule_cache *cache,
cd73de47 475 const struct object_id *treeish_name, const char *key,
959b5455
HV
476 enum lookup_type lookup_type)
477{
478 struct strbuf rev = STRBUF_INIT;
479 unsigned long config_size;
0918e250 480 char *config = NULL;
cd73de47 481 struct object_id oid;
959b5455
HV
482 enum object_type type;
483 const struct submodule *submodule = NULL;
484 struct parse_config_parameter parameter;
485
486 /*
487 * If any parameter except the cache is a NULL pointer just
488 * return the first submodule. Can be used to check whether
489 * there are any submodules parsed.
490 */
73c293bb 491 if (!treeish_name || !key) {
959b5455
HV
492 struct hashmap_iter iter;
493 struct submodule_entry *entry;
494
01d98e8a 495 entry = hashmap_iter_first(&cache->for_name, &iter);
959b5455
HV
496 if (!entry)
497 return NULL;
498 return entry->config;
499 }
500
cd73de47 501 if (!gitmodule_oid_from_commit(treeish_name, &oid, &rev))
0918e250 502 goto out;
959b5455
HV
503
504 switch (lookup_type) {
505 case lookup_name:
cd73de47 506 submodule = cache_lookup_name(cache, oid.hash, key);
959b5455
HV
507 break;
508 case lookup_path:
cd73de47 509 submodule = cache_lookup_path(cache, oid.hash, key);
959b5455
HV
510 break;
511 }
512 if (submodule)
0918e250 513 goto out;
959b5455 514
cd73de47 515 config = read_sha1_file(oid.hash, &type, &config_size);
0918e250
HV
516 if (!config || type != OBJ_BLOB)
517 goto out;
959b5455
HV
518
519 /* fill the submodule config into the cache */
520 parameter.cache = cache;
cd73de47 521 parameter.treeish_name = treeish_name->hash;
522 parameter.gitmodules_sha1 = oid.hash;
959b5455 523 parameter.overwrite = 0;
1b8132d9 524 git_config_from_mem(parse_config, CONFIG_ORIGIN_SUBMODULE_BLOB, rev.buf,
473166b9 525 config, config_size, &parameter);
514dea90 526 strbuf_release(&rev);
959b5455
HV
527 free(config);
528
529 switch (lookup_type) {
530 case lookup_name:
cd73de47 531 return cache_lookup_name(cache, oid.hash, key);
959b5455 532 case lookup_path:
cd73de47 533 return cache_lookup_path(cache, oid.hash, key);
959b5455
HV
534 default:
535 return NULL;
536 }
0918e250
HV
537
538out:
539 strbuf_release(&rev);
540 free(config);
541 return submodule;
959b5455
HV
542}
543
bf12fcdf 544static void submodule_cache_check_init(struct repository *repo)
959b5455 545{
bf12fcdf 546 if (repo->submodule_cache && repo->submodule_cache->initialized)
959b5455
HV
547 return;
548
bf12fcdf
BW
549 if (!repo->submodule_cache)
550 repo->submodule_cache = submodule_cache_alloc();
551
552 submodule_cache_init(repo->submodule_cache);
959b5455
HV
553}
554
1b796ace 555static int gitmodules_cb(const char *var, const char *value, void *data)
851e18c3 556{
1b796ace 557 struct repository *repo = data;
851e18c3 558 struct parse_config_parameter parameter;
bf12fcdf
BW
559
560 submodule_cache_check_init(repo);
561
562 parameter.cache = repo->submodule_cache;
73c293bb 563 parameter.treeish_name = NULL;
851e18c3
HV
564 parameter.gitmodules_sha1 = null_sha1;
565 parameter.overwrite = 1;
566
851e18c3
HV
567 return parse_config(var, value, &parameter);
568}
569
1b796ace 570void repo_read_gitmodules(struct repository *repo)
bf12fcdf 571{
1b796ace
BW
572 if (repo->worktree) {
573 char *gitmodules;
574
575 if (repo_read_index(repo) < 0)
576 return;
577
578 gitmodules = repo_worktree_path(repo, GITMODULES_FILE);
579
580 if (!is_gitmodules_unmerged(repo->index))
581 git_config_from_file(gitmodules_cb, gitmodules, repo);
582
583 free(gitmodules);
584 }
585}
586
587void gitmodules_config_oid(const struct object_id *commit_oid)
588{
589 struct strbuf rev = STRBUF_INIT;
590 struct object_id oid;
591
592 if (gitmodule_oid_from_commit(commit_oid, &oid, &rev)) {
593 git_config_from_blob_oid(gitmodules_cb, rev.buf,
594 &oid, the_repository);
595 }
596 strbuf_release(&rev);
bf12fcdf
BW
597}
598
cd73de47 599const struct submodule *submodule_from_name(const struct object_id *treeish_name,
959b5455
HV
600 const char *name)
601{
bf12fcdf
BW
602 submodule_cache_check_init(the_repository);
603 return config_from(the_repository->submodule_cache, treeish_name, name, lookup_name);
959b5455
HV
604}
605
cd73de47 606const struct submodule *submodule_from_path(const struct object_id *treeish_name,
959b5455
HV
607 const char *path)
608{
bf12fcdf
BW
609 submodule_cache_check_init(the_repository);
610 return config_from(the_repository->submodule_cache, treeish_name, path, lookup_path);
611}
612
613const struct submodule *submodule_from_cache(struct repository *repo,
cd73de47 614 const struct object_id *treeish_name,
bf12fcdf
BW
615 const char *key)
616{
617 submodule_cache_check_init(repo);
618 return config_from(repo->submodule_cache, treeish_name,
619 key, lookup_path);
959b5455
HV
620}
621
622void submodule_free(void)
623{
bf12fcdf
BW
624 if (the_repository->submodule_cache)
625 submodule_cache_clear(the_repository->submodule_cache);
959b5455 626}