]> git.ipfire.org Git - thirdparty/git.git/blame - builtin/sparse-checkout.c
Merge branch 'jk/clone-allow-bare-and-o-together'
[thirdparty/git.git] / builtin / sparse-checkout.c
CommitLineData
94c0956b 1#include "builtin.h"
4ce50436 2#include "cache.h"
94c0956b
DS
3#include "config.h"
4#include "dir.h"
5#include "parse-options.h"
6#include "pathspec.h"
7#include "repository.h"
8#include "run-command.h"
9#include "strbuf.h"
af09ce24 10#include "string-list.h"
e091228e
DS
11#include "cache-tree.h"
12#include "lockfile.h"
13#include "resolve-undo.h"
14#include "unpack-trees.h"
cff4e913 15#include "wt-status.h"
d585f0e7 16#include "quote.h"
122ba1f7 17#include "sparse-index.h"
7316dc5f 18#include "worktree.h"
94c0956b 19
416adc87
DS
20static const char *empty_base = "";
21
94c0956b 22static char const * const builtin_sparse_checkout_usage[] = {
5644ca28 23 N_("git sparse-checkout (init|list|set|add|reapply|disable) <options>"),
94c0956b
DS
24 NULL
25};
26
94c0956b
DS
27static void write_patterns_to_file(FILE *fp, struct pattern_list *pl)
28{
29 int i;
30
31 for (i = 0; i < pl->nr; i++) {
32 struct path_pattern *p = pl->patterns[i];
33
34 if (p->flags & PATTERN_FLAG_NEGATIVE)
35 fprintf(fp, "!");
36
37 fprintf(fp, "%s", p->pattern);
38
39 if (p->flags & PATTERN_FLAG_MUSTBEDIR)
40 fprintf(fp, "/");
41
42 fprintf(fp, "\n");
43 }
44}
45
75d3bee1 46static char const * const builtin_sparse_checkout_list_usage[] = {
959d670d 47 "git sparse-checkout list",
75d3bee1
JK
48 NULL
49};
50
1c3502b1 51static int sparse_checkout_list(int argc, const char **argv, const char *prefix)
94c0956b 52{
75d3bee1
JK
53 static struct option builtin_sparse_checkout_list_options[] = {
54 OPT_END(),
55 };
94c0956b
DS
56 struct pattern_list pl;
57 char *sparse_filename;
58 int res;
59
45c5e470
EN
60 if (!core_apply_sparse_checkout)
61 die(_("this worktree is not sparse"));
62
ecd2d3ef 63 argc = parse_options(argc, argv, prefix,
75d3bee1
JK
64 builtin_sparse_checkout_list_options,
65 builtin_sparse_checkout_list_usage, 0);
66
94c0956b
DS
67 memset(&pl, 0, sizeof(pl));
68
de11951b
DS
69 pl.use_cone_patterns = core_sparse_checkout_cone;
70
94c0956b 71 sparse_filename = get_sparse_checkout_filename();
1679d60b 72 res = add_patterns_from_file_to_list(sparse_filename, "", 0, &pl, NULL, 0);
94c0956b
DS
73 free(sparse_filename);
74
75 if (res < 0) {
76 warning(_("this worktree is not sparse (sparse-checkout file may not exist)"));
77 return 0;
78 }
79
de11951b
DS
80 if (pl.use_cone_patterns) {
81 int i;
82 struct pattern_entry *pe;
83 struct hashmap_iter iter;
84 struct string_list sl = STRING_LIST_INIT_DUP;
85
86 hashmap_for_each_entry(&pl.recursive_hashmap, &iter, pe, ent) {
87 /* pe->pattern starts with "/", skip it */
88 string_list_insert(&sl, pe->pattern + 1);
89 }
90
91 string_list_sort(&sl);
92
e55682ea
DS
93 for (i = 0; i < sl.nr; i++) {
94 quote_c_style(sl.items[i].string, NULL, stdout, 0);
95 printf("\n");
96 }
de11951b
DS
97
98 return 0;
99 }
100
94c0956b
DS
101 write_patterns_to_file(stdout, &pl);
102 clear_pattern_list(&pl);
103
104 return 0;
105}
106
55dfcf95
DS
107static void clean_tracked_sparse_directories(struct repository *r)
108{
109 int i, was_full = 0;
110 struct strbuf path = STRBUF_INIT;
111 size_t pathlen;
112 struct string_list_item *item;
113 struct string_list sparse_dirs = STRING_LIST_INIT_DUP;
114
115 /*
116 * If we are not using cone mode patterns, then we cannot
117 * delete directories outside of the sparse cone.
118 */
119 if (!r || !r->index || !r->worktree)
120 return;
121 if (init_sparse_checkout_patterns(r->index) ||
122 !r->index->sparse_checkout_patterns->use_cone_patterns)
123 return;
124
125 /*
126 * Use the sparse index as a data structure to assist finding
127 * directories that are safe to delete. This conversion to a
128 * sparse index will not delete directories that contain
129 * conflicted entries or submodules.
130 */
9fadb373 131 if (r->index->sparse_index == INDEX_EXPANDED) {
55dfcf95
DS
132 /*
133 * If something, such as a merge conflict or other concern,
134 * prevents us from converting to a sparse index, then do
135 * not try deleting files.
136 */
137 if (convert_to_sparse(r->index, SPARSE_INDEX_MEMORY_ONLY))
138 return;
139 was_full = 1;
140 }
141
142 strbuf_addstr(&path, r->worktree);
143 strbuf_complete(&path, '/');
144 pathlen = path.len;
145
146 /*
147 * Collect directories that have gone out of scope but also
148 * exist on disk, so there is some work to be done. We need to
149 * store the entries in a list before exploring, since that might
150 * expand the sparse-index again.
151 */
152 for (i = 0; i < r->index->cache_nr; i++) {
153 struct cache_entry *ce = r->index->cache[i];
154
155 if (S_ISSPARSEDIR(ce->ce_mode) &&
156 repo_file_exists(r, ce->name))
157 string_list_append(&sparse_dirs, ce->name);
158 }
159
160 for_each_string_list_item(item, &sparse_dirs) {
161 struct dir_struct dir = DIR_INIT;
162 struct pathspec p = { 0 };
163 struct strvec s = STRVEC_INIT;
164
165 strbuf_setlen(&path, pathlen);
166 strbuf_addstr(&path, item->string);
167
168 dir.flags |= DIR_SHOW_IGNORED_TOO;
169
170 setup_standard_excludes(&dir);
171 strvec_push(&s, path.buf);
172
173 parse_pathspec(&p, PATHSPEC_GLOB, 0, NULL, s.v);
174 fill_directory(&dir, r->index, &p);
175
176 if (dir.nr) {
177 warning(_("directory '%s' contains untracked files,"
178 " but is not in the sparse-checkout cone"),
179 item->string);
180 } else if (remove_dir_recursively(&path, 0)) {
181 /*
182 * Removal is "best effort". If something blocks
183 * the deletion, then continue with a warning.
184 */
185 warning(_("failed to remove directory '%s'"),
186 item->string);
187 }
188
0f03f04c
EN
189 strvec_clear(&s);
190 clear_pathspec(&p);
55dfcf95
DS
191 dir_clear(&dir);
192 }
193
194 string_list_clear(&sparse_dirs, 0);
195 strbuf_release(&path);
196
197 if (was_full)
198 ensure_full_index(r->index);
199}
200
e091228e 201static int update_working_directory(struct pattern_list *pl)
bab3c359 202{
f56f31af 203 enum update_sparsity_result result;
e091228e
DS
204 struct unpack_trees_options o;
205 struct lock_file lock_file = LOCK_INIT;
e091228e 206 struct repository *r = the_repository;
bab3c359 207
b5bfc08a
EN
208 /* If no branch has been checked out, there are no updates to make. */
209 if (is_index_unborn(r->index))
210 return UPDATE_SPARSITY_SUCCESS;
211
836e25c5
DS
212 r->index->sparse_checkout_patterns = pl;
213
e091228e
DS
214 memset(&o, 0, sizeof(o));
215 o.verbose_update = isatty(2);
e091228e 216 o.update = 1;
e091228e
DS
217 o.head_idx = -1;
218 o.src_index = r->index;
219 o.dst_index = r->index;
220 o.skip_sparse_checkout = 0;
221 o.pl = pl;
e091228e 222
e091228e
DS
223 setup_work_tree();
224
e091228e
DS
225 repo_hold_locked_index(r, &lock_file, LOCK_DIE_ON_ERROR);
226
4ee5d50f 227 setup_unpack_trees_porcelain(&o, "sparse-checkout");
f56f31af 228 result = update_sparsity(&o);
4ee5d50f 229 clear_unpack_trees_porcelain(&o);
e091228e 230
f56f31af
EN
231 if (result == UPDATE_SPARSITY_WARNINGS)
232 /*
233 * We don't do any special handling of warnings from untracked
234 * files in the way or dirty entries that can't be removed.
235 */
236 result = UPDATE_SPARSITY_SUCCESS;
237 if (result == UPDATE_SPARSITY_SUCCESS)
e091228e 238 write_locked_index(r->index, &lock_file, COMMIT_LOCK);
f56f31af 239 else
e091228e 240 rollback_lock_file(&lock_file);
bab3c359 241
55dfcf95
DS
242 clean_tracked_sparse_directories(r);
243
836e25c5 244 r->index->sparse_checkout_patterns = NULL;
bab3c359
DS
245 return result;
246}
247
d585f0e7
DS
248static char *escaped_pattern(char *pattern)
249{
250 char *p = pattern;
251 struct strbuf final = STRBUF_INIT;
252
253 while (*p) {
e53ffe27 254 if (is_glob_special(*p))
d585f0e7
DS
255 strbuf_addch(&final, '\\');
256
257 strbuf_addch(&final, *p);
258 p++;
259 }
260
261 return strbuf_detach(&final, NULL);
262}
263
af09ce24
DS
264static void write_cone_to_file(FILE *fp, struct pattern_list *pl)
265{
266 int i;
267 struct pattern_entry *pe;
268 struct hashmap_iter iter;
269 struct string_list sl = STRING_LIST_INIT_DUP;
e9de487a 270 struct strbuf parent_pattern = STRBUF_INIT;
af09ce24 271
e9de487a
DS
272 hashmap_for_each_entry(&pl->parent_hashmap, &iter, pe, ent) {
273 if (hashmap_get_entry(&pl->recursive_hashmap, pe, ent, NULL))
274 continue;
275
276 if (!hashmap_contains_parent(&pl->recursive_hashmap,
277 pe->pattern,
278 &parent_pattern))
279 string_list_insert(&sl, pe->pattern);
280 }
af09ce24
DS
281
282 string_list_sort(&sl);
283 string_list_remove_duplicates(&sl, 0);
284
285 fprintf(fp, "/*\n!/*/\n");
286
287 for (i = 0; i < sl.nr; i++) {
d585f0e7 288 char *pattern = escaped_pattern(sl.items[i].string);
af09ce24
DS
289
290 if (strlen(pattern))
291 fprintf(fp, "%s/\n!%s/*/\n", pattern, pattern);
d585f0e7 292 free(pattern);
af09ce24
DS
293 }
294
295 string_list_clear(&sl, 0);
296
e9de487a
DS
297 hashmap_for_each_entry(&pl->recursive_hashmap, &iter, pe, ent) {
298 if (!hashmap_contains_parent(&pl->recursive_hashmap,
299 pe->pattern,
300 &parent_pattern))
301 string_list_insert(&sl, pe->pattern);
302 }
303
304 strbuf_release(&parent_pattern);
af09ce24
DS
305
306 string_list_sort(&sl);
307 string_list_remove_duplicates(&sl, 0);
308
309 for (i = 0; i < sl.nr; i++) {
d585f0e7 310 char *pattern = escaped_pattern(sl.items[i].string);
af09ce24 311 fprintf(fp, "%s/\n", pattern);
d585f0e7 312 free(pattern);
af09ce24
DS
313 }
314}
315
316static int write_patterns_and_update(struct pattern_list *pl)
317{
318 char *sparse_filename;
319 FILE *fp;
fb10ca5b
DS
320 int fd;
321 struct lock_file lk = LOCK_INIT;
e091228e
DS
322 int result;
323
fb10ca5b 324 sparse_filename = get_sparse_checkout_filename();
3c754067
DS
325
326 if (safe_create_leading_directories(sparse_filename))
327 die(_("failed to create directory for sparse-checkout file"));
328
fb10ca5b
DS
329 fd = hold_lock_file_for_update(&lk, sparse_filename,
330 LOCK_DIE_ON_ERROR);
ef3fe214 331 free(sparse_filename);
e091228e 332
fb10ca5b 333 result = update_working_directory(pl);
e091228e 334 if (result) {
fb10ca5b 335 rollback_lock_file(&lk);
e091228e
DS
336 clear_pattern_list(pl);
337 update_working_directory(NULL);
338 return result;
339 }
af09ce24 340
fb10ca5b 341 fp = xfdopen(fd, "w");
af09ce24
DS
342
343 if (core_sparse_checkout_cone)
344 write_cone_to_file(fp, pl);
345 else
346 write_patterns_to_file(fp, pl);
347
fb10ca5b
DS
348 fflush(fp);
349 commit_lock_file(&lk);
e091228e 350
e091228e 351 clear_pattern_list(pl);
af09ce24 352
e091228e 353 return 0;
af09ce24
DS
354}
355
bab3c359
DS
356enum sparse_checkout_mode {
357 MODE_NO_PATTERNS = 0,
358 MODE_ALL_PATTERNS = 1,
af09ce24 359 MODE_CONE_PATTERNS = 2,
bab3c359
DS
360};
361
362static int set_config(enum sparse_checkout_mode mode)
363{
7316dc5f
DS
364 /* Update to use worktree config, if not already. */
365 if (init_worktree_config(the_repository)) {
366 error(_("failed to initialize worktree config"));
bab3c359
DS
367 return 1;
368 }
369
7316dc5f
DS
370 if (repo_config_set_worktree_gently(the_repository,
371 "core.sparseCheckout",
372 mode ? "true" : "false") ||
373 repo_config_set_worktree_gently(the_repository,
374 "core.sparseCheckoutCone",
375 mode == MODE_CONE_PATTERNS ?
376 "true" : "false"))
377 return 1;
af09ce24 378
dcc5fd5f 379 if (mode == MODE_NO_PATTERNS)
7316dc5f 380 return set_sparse_index_config(the_repository, 0);
dcc5fd5f 381
bab3c359
DS
382 return 0;
383}
384
be61fd11
EN
385static int update_modes(int *cone_mode, int *sparse_index)
386{
387 int mode, record_mode;
388
389 /* Determine if we need to record the mode; ensure sparse checkout on */
390 record_mode = (*cone_mode != -1) || !core_apply_sparse_checkout;
391
392 /* If not specified, use previous definition of cone mode */
393 if (*cone_mode == -1 && core_apply_sparse_checkout)
394 *cone_mode = core_sparse_checkout_cone;
395
396 /* Set cone/non-cone mode appropriately */
397 core_apply_sparse_checkout = 1;
2d95707a 398 if (*cone_mode == 1 || *cone_mode == -1) {
be61fd11
EN
399 mode = MODE_CONE_PATTERNS;
400 core_sparse_checkout_cone = 1;
401 } else {
402 mode = MODE_ALL_PATTERNS;
d526b4db 403 core_sparse_checkout_cone = 0;
be61fd11
EN
404 }
405 if (record_mode && set_config(mode))
406 return 1;
407
408 /* Set sparse-index/non-sparse-index mode if specified */
409 if (*sparse_index >= 0) {
410 if (set_sparse_index_config(the_repository, *sparse_index) < 0)
411 die(_("failed to modify sparse-index config"));
412
413 /* force an index rewrite */
414 repo_read_index(the_repository);
415 the_repository->index->updated_workdir = 1;
2d443389
DS
416
417 if (!*sparse_index)
418 ensure_full_index(the_repository->index);
be61fd11
EN
419 }
420
421 return 0;
422}
423
af09ce24 424static char const * const builtin_sparse_checkout_init_usage[] = {
959d670d 425 "git sparse-checkout init [--cone] [--[no-]sparse-index]",
af09ce24
DS
426 NULL
427};
428
429static struct sparse_checkout_init_opts {
430 int cone_mode;
122ba1f7 431 int sparse_index;
af09ce24
DS
432} init_opts;
433
1c3502b1 434static int sparse_checkout_init(int argc, const char **argv, const char *prefix)
bab3c359
DS
435{
436 struct pattern_list pl;
437 char *sparse_filename;
bab3c359 438 int res;
d89f09c8 439 struct object_id oid;
416adc87 440 struct strbuf pattern = STRBUF_INIT;
bab3c359 441
af09ce24
DS
442 static struct option builtin_sparse_checkout_init_options[] = {
443 OPT_BOOL(0, "cone", &init_opts.cone_mode,
444 N_("initialize the sparse-checkout in cone mode")),
122ba1f7
DS
445 OPT_BOOL(0, "sparse-index", &init_opts.sparse_index,
446 N_("toggle the use of a sparse index")),
af09ce24
DS
447 OPT_END(),
448 };
449
cff4e913 450 repo_read_index(the_repository);
cff4e913 451
be61fd11 452 init_opts.cone_mode = -1;
122ba1f7
DS
453 init_opts.sparse_index = -1;
454
ecd2d3ef 455 argc = parse_options(argc, argv, prefix,
af09ce24
DS
456 builtin_sparse_checkout_init_options,
457 builtin_sparse_checkout_init_usage, 0);
458
be61fd11 459 if (update_modes(&init_opts.cone_mode, &init_opts.sparse_index))
bab3c359
DS
460 return 1;
461
462 memset(&pl, 0, sizeof(pl));
463
464 sparse_filename = get_sparse_checkout_filename();
1679d60b 465 res = add_patterns_from_file_to_list(sparse_filename, "", 0, &pl, NULL, 0);
bab3c359
DS
466
467 /* If we already have a sparse-checkout file, use it. */
468 if (res >= 0) {
469 free(sparse_filename);
416adc87 470 return update_working_directory(NULL);
bab3c359
DS
471 }
472
416adc87
DS
473 if (get_oid("HEAD", &oid)) {
474 FILE *fp;
bab3c359 475
416adc87 476 /* assume we are in a fresh repo, but update the sparse-checkout file */
7f44842a
JT
477 if (safe_create_leading_directories(sparse_filename))
478 die(_("unable to create leading directories of %s"),
479 sparse_filename);
416adc87
DS
480 fp = xfopen(sparse_filename, "w");
481 if (!fp)
482 die(_("failed to open '%s'"), sparse_filename);
bab3c359 483
416adc87
DS
484 free(sparse_filename);
485 fprintf(fp, "/*\n!/*/\n");
486 fclose(fp);
d89f09c8
DS
487 return 0;
488 }
489
416adc87
DS
490 strbuf_addstr(&pattern, "/*");
491 add_pattern(strbuf_detach(&pattern, NULL), empty_base, 0, &pl, 0);
492 strbuf_addstr(&pattern, "!/*/");
493 add_pattern(strbuf_detach(&pattern, NULL), empty_base, 0, &pl, 0);
dcc5fd5f 494 pl.use_cone_patterns = init_opts.cone_mode;
416adc87
DS
495
496 return write_patterns_and_update(&pl);
bab3c359
DS
497}
498
af09ce24 499static void insert_recursive_pattern(struct pattern_list *pl, struct strbuf *path)
f6039a94 500{
af09ce24
DS
501 struct pattern_entry *e = xmalloc(sizeof(*e));
502 e->patternlen = path->len;
503 e->pattern = strbuf_detach(path, NULL);
74318423 504 hashmap_entry_init(&e->ent, fspathhash(e->pattern));
f6039a94 505
af09ce24 506 hashmap_add(&pl->recursive_hashmap, &e->ent);
f6039a94 507
af09ce24
DS
508 while (e->patternlen) {
509 char *slash = strrchr(e->pattern, '/');
510 char *oldpattern = e->pattern;
511 size_t newlen;
512
391c3a10 513 if (!slash || slash == e->pattern)
af09ce24
DS
514 break;
515
516 newlen = slash - e->pattern;
517 e = xmalloc(sizeof(struct pattern_entry));
518 e->patternlen = newlen;
519 e->pattern = xstrndup(oldpattern, newlen);
74318423 520 hashmap_entry_init(&e->ent, fspathhash(e->pattern));
af09ce24
DS
521
522 if (!hashmap_get_entry(&pl->parent_hashmap, e, ent, NULL))
523 hashmap_add(&pl->parent_hashmap, &e->ent);
524 }
525}
526
527static void strbuf_to_cone_pattern(struct strbuf *line, struct pattern_list *pl)
528{
529 strbuf_trim(line);
530
531 strbuf_trim_trailing_dir_sep(line);
532
ef076599
DS
533 if (strbuf_normalize_path(line))
534 die(_("could not normalize path %s"), line->buf);
535
af09ce24
DS
536 if (!line->len)
537 return;
538
539 if (line->buf[0] != '/')
a91cc7fa 540 strbuf_insertstr(line, 0, "/");
af09ce24
DS
541
542 insert_recursive_pattern(pl, line);
f6039a94
DS
543}
544
6fb705ab 545static void add_patterns_from_input(struct pattern_list *pl,
1530ff35
EN
546 int argc, const char **argv,
547 int use_stdin)
f6039a94 548{
f6039a94 549 int i;
af09ce24 550 if (core_sparse_checkout_cone) {
7bffca95
DS
551 struct strbuf line = STRBUF_INIT;
552
6fb705ab
DS
553 hashmap_init(&pl->recursive_hashmap, pl_hashmap_cmp, NULL, 0);
554 hashmap_init(&pl->parent_hashmap, pl_hashmap_cmp, NULL, 0);
555 pl->use_cone_patterns = 1;
af09ce24 556
1530ff35 557 if (use_stdin) {
bd64de42
DS
558 struct strbuf unquoted = STRBUF_INIT;
559 while (!strbuf_getline(&line, stdin)) {
560 if (line.buf[0] == '"') {
561 strbuf_reset(&unquoted);
562 if (unquote_c_style(&unquoted, line.buf, NULL))
563 die(_("unable to unquote C-style string '%s'"),
564 line.buf);
565
566 strbuf_swap(&unquoted, &line);
567 }
568
6fb705ab 569 strbuf_to_cone_pattern(&line, pl);
bd64de42
DS
570 }
571
572 strbuf_release(&unquoted);
af09ce24
DS
573 } else {
574 for (i = 0; i < argc; i++) {
575 strbuf_setlen(&line, 0);
576 strbuf_addstr(&line, argv[i]);
6fb705ab 577 strbuf_to_cone_pattern(&line, pl);
af09ce24 578 }
7bffca95
DS
579 }
580 } else {
1530ff35 581 if (use_stdin) {
af09ce24
DS
582 struct strbuf line = STRBUF_INIT;
583
584 while (!strbuf_getline(&line, stdin)) {
585 size_t len;
586 char *buf = strbuf_detach(&line, &len);
6fb705ab 587 add_pattern(buf, empty_base, 0, pl, 0);
af09ce24
DS
588 }
589 } else {
590 for (i = 0; i < argc; i++)
6fb705ab 591 add_pattern(argv[i], empty_base, 0, pl, 0);
af09ce24 592 }
7bffca95 593 }
6fb705ab
DS
594}
595
4bf0c06c
DS
596enum modify_type {
597 REPLACE,
2631dc87 598 ADD,
4bf0c06c
DS
599};
600
2631dc87 601static void add_patterns_cone_mode(int argc, const char **argv,
1530ff35
EN
602 struct pattern_list *pl,
603 int use_stdin)
2631dc87
DS
604{
605 struct strbuf buffer = STRBUF_INIT;
606 struct pattern_entry *pe;
607 struct hashmap_iter iter;
608 struct pattern_list existing;
609 char *sparse_filename = get_sparse_checkout_filename();
610
1530ff35 611 add_patterns_from_input(pl, argc, argv, use_stdin);
2631dc87
DS
612
613 memset(&existing, 0, sizeof(existing));
614 existing.use_cone_patterns = core_sparse_checkout_cone;
615
616 if (add_patterns_from_file_to_list(sparse_filename, "", 0,
1679d60b 617 &existing, NULL, 0))
2631dc87
DS
618 die(_("unable to load existing sparse-checkout patterns"));
619 free(sparse_filename);
620
a3eca584
DS
621 if (!existing.use_cone_patterns)
622 die(_("existing sparse-checkout patterns do not use cone mode"));
623
2631dc87
DS
624 hashmap_for_each_entry(&existing.recursive_hashmap, &iter, pe, ent) {
625 if (!hashmap_contains_parent(&pl->recursive_hashmap,
626 pe->pattern, &buffer) ||
627 !hashmap_contains_parent(&pl->parent_hashmap,
628 pe->pattern, &buffer)) {
629 strbuf_reset(&buffer);
630 strbuf_addstr(&buffer, pe->pattern);
631 insert_recursive_pattern(pl, &buffer);
632 }
633 }
634
635 clear_pattern_list(&existing);
636 strbuf_release(&buffer);
637}
638
639static void add_patterns_literal(int argc, const char **argv,
1530ff35
EN
640 struct pattern_list *pl,
641 int use_stdin)
2631dc87
DS
642{
643 char *sparse_filename = get_sparse_checkout_filename();
644 if (add_patterns_from_file_to_list(sparse_filename, "", 0,
1679d60b 645 pl, NULL, 0))
2631dc87
DS
646 die(_("unable to load existing sparse-checkout patterns"));
647 free(sparse_filename);
1530ff35 648 add_patterns_from_input(pl, argc, argv, use_stdin);
2631dc87
DS
649}
650
1530ff35
EN
651static int modify_pattern_list(int argc, const char **argv, int use_stdin,
652 enum modify_type m)
6fb705ab 653{
6fb705ab
DS
654 int result;
655 int changed_config = 0;
836e25c5 656 struct pattern_list *pl = xcalloc(1, sizeof(*pl));
6fb705ab 657
2631dc87
DS
658 switch (m) {
659 case ADD:
660 if (core_sparse_checkout_cone)
1530ff35 661 add_patterns_cone_mode(argc, argv, pl, use_stdin);
2631dc87 662 else
1530ff35 663 add_patterns_literal(argc, argv, pl, use_stdin);
2631dc87
DS
664 break;
665
666 case REPLACE:
1530ff35 667 add_patterns_from_input(pl, argc, argv, use_stdin);
2631dc87
DS
668 break;
669 }
f6039a94
DS
670
671 if (!core_apply_sparse_checkout) {
672 set_config(MODE_ALL_PATTERNS);
673 core_apply_sparse_checkout = 1;
674 changed_config = 1;
675 }
676
836e25c5 677 result = write_patterns_and_update(pl);
f6039a94
DS
678
679 if (result && changed_config)
680 set_config(MODE_NO_PATTERNS);
681
836e25c5
DS
682 clear_pattern_list(pl);
683 free(pl);
f6039a94
DS
684 return result;
685}
686
4ce50436
EN
687static void sanitize_paths(int argc, const char **argv,
688 const char *prefix, int skip_checks)
bb8b5e9a 689{
4ce50436
EN
690 int i;
691
bb8b5e9a
EN
692 if (!argc)
693 return;
694
695 if (prefix && *prefix && core_sparse_checkout_cone) {
696 /*
697 * The args are not pathspecs, so unfortunately we
698 * cannot imitate how cmd_add() uses parse_pathspec().
699 */
bb8b5e9a
EN
700 int prefix_len = strlen(prefix);
701
702 for (i = 0; i < argc; i++)
703 argv[i] = prefix_path(prefix, prefix_len, argv[i]);
704 }
705
4ce50436
EN
706 if (skip_checks)
707 return;
708
bb8b5e9a
EN
709 if (prefix && *prefix && !core_sparse_checkout_cone)
710 die(_("please run from the toplevel directory in non-cone mode"));
711
8dd7c473
EN
712 if (core_sparse_checkout_cone) {
713 for (i = 0; i < argc; i++) {
714 if (argv[i][0] == '/')
715 die(_("specify directories rather than patterns (no leading slash)"));
716 if (argv[i][0] == '!')
717 die(_("specify directories rather than patterns. If your directory starts with a '!', pass --skip-checks"));
718 if (strpbrk(argv[i], "*?[]"))
719 die(_("specify directories rather than patterns. If your directory really has any of '*?[]\\' in it, pass --skip-checks"));
720 }
721 }
722
4ce50436
EN
723 for (i = 0; i < argc; i++) {
724 struct cache_entry *ce;
725 struct index_state *index = the_repository->index;
726 int pos = index_name_pos(index, argv[i], strlen(argv[i]));
727
728 if (pos < 0)
729 continue;
730 ce = index->cache[pos];
731 if (S_ISSPARSEDIR(ce->ce_mode))
732 continue;
733
734 if (core_sparse_checkout_cone)
735 die(_("'%s' is not a directory; to treat it as a directory anyway, rerun with --skip-checks"), argv[i]);
736 else
737 warning(_("pass a leading slash before paths such as '%s' if you want a single file (see NON-CONE PROBLEMS in the git-sparse-checkout manual)."), argv[i]);
738 }
bb8b5e9a
EN
739}
740
0b624e03 741static char const * const builtin_sparse_checkout_add_usage[] = {
4ce50436 742 N_("git sparse-checkout add [--skip-checks] (--stdin | <patterns>)"),
0b624e03
EN
743 NULL
744};
745
746static struct sparse_checkout_add_opts {
4ce50436 747 int skip_checks;
0b624e03
EN
748 int use_stdin;
749} add_opts;
750
751static int sparse_checkout_add(int argc, const char **argv, const char *prefix)
752{
753 static struct option builtin_sparse_checkout_add_options[] = {
4ce50436
EN
754 OPT_BOOL_F(0, "skip-checks", &add_opts.skip_checks,
755 N_("skip some sanity checks on the given paths that might give false positives"),
756 PARSE_OPT_NONEG),
0b624e03
EN
757 OPT_BOOL(0, "stdin", &add_opts.use_stdin,
758 N_("read patterns from standard in")),
759 OPT_END(),
760 };
761
45c5e470
EN
762 if (!core_apply_sparse_checkout)
763 die(_("no sparse-checkout to add to"));
764
0b624e03
EN
765 repo_read_index(the_repository);
766
767 argc = parse_options(argc, argv, prefix,
768 builtin_sparse_checkout_add_options,
769 builtin_sparse_checkout_add_usage,
99d86d60 770 PARSE_OPT_KEEP_UNKNOWN_OPT);
0b624e03 771
4ce50436 772 sanitize_paths(argc, argv, prefix, add_opts.skip_checks);
bb8b5e9a 773
0b624e03
EN
774 return modify_pattern_list(argc, argv, add_opts.use_stdin, ADD);
775}
776
777static char const * const builtin_sparse_checkout_set_usage[] = {
4ce50436 778 N_("git sparse-checkout set [--[no-]cone] [--[no-]sparse-index] [--skip-checks] (--stdin | <patterns>)"),
0b624e03
EN
779 NULL
780};
781
782static struct sparse_checkout_set_opts {
f2e3a218
EN
783 int cone_mode;
784 int sparse_index;
4ce50436 785 int skip_checks;
0b624e03
EN
786 int use_stdin;
787} set_opts;
788
789static int sparse_checkout_set(int argc, const char **argv, const char *prefix)
4bf0c06c 790{
f2e3a218
EN
791 int default_patterns_nr = 2;
792 const char *default_patterns[] = {"/*", "!/*/", NULL};
793
4bf0c06c 794 static struct option builtin_sparse_checkout_set_options[] = {
f2e3a218
EN
795 OPT_BOOL(0, "cone", &set_opts.cone_mode,
796 N_("initialize the sparse-checkout in cone mode")),
797 OPT_BOOL(0, "sparse-index", &set_opts.sparse_index,
798 N_("toggle the use of a sparse index")),
4ce50436
EN
799 OPT_BOOL_F(0, "skip-checks", &set_opts.skip_checks,
800 N_("skip some sanity checks on the given paths that might give false positives"),
801 PARSE_OPT_NONEG),
f85751a1
EN
802 OPT_BOOL_F(0, "stdin", &set_opts.use_stdin,
803 N_("read patterns from standard in"),
804 PARSE_OPT_NONEG),
4bf0c06c
DS
805 OPT_END(),
806 };
807
808 repo_read_index(the_repository);
4bf0c06c 809
f2e3a218
EN
810 set_opts.cone_mode = -1;
811 set_opts.sparse_index = -1;
812
4bf0c06c
DS
813 argc = parse_options(argc, argv, prefix,
814 builtin_sparse_checkout_set_options,
815 builtin_sparse_checkout_set_usage,
99d86d60 816 PARSE_OPT_KEEP_UNKNOWN_OPT);
4bf0c06c 817
f2e3a218
EN
818 if (update_modes(&set_opts.cone_mode, &set_opts.sparse_index))
819 return 1;
820
821 /*
822 * Cone mode automatically specifies the toplevel directory. For
823 * non-cone mode, if nothing is specified, manually select just the
824 * top-level directory (much as 'init' would do).
825 */
826 if (!core_sparse_checkout_cone && argc == 0) {
827 argv = default_patterns;
828 argc = default_patterns_nr;
bb8b5e9a 829 } else {
4ce50436 830 sanitize_paths(argc, argv, prefix, set_opts.skip_checks);
f2e3a218
EN
831 }
832
0b624e03 833 return modify_pattern_list(argc, argv, set_opts.use_stdin, REPLACE);
4bf0c06c
DS
834}
835
75d3bee1 836static char const * const builtin_sparse_checkout_reapply_usage[] = {
959d670d 837 "git sparse-checkout reapply [--[no-]cone] [--[no-]sparse-index]",
75d3bee1
JK
838 NULL
839};
840
4e256731
EN
841static struct sparse_checkout_reapply_opts {
842 int cone_mode;
843 int sparse_index;
844} reapply_opts;
845
1c3502b1
SG
846static int sparse_checkout_reapply(int argc, const char **argv,
847 const char *prefix)
5644ca28 848{
75d3bee1 849 static struct option builtin_sparse_checkout_reapply_options[] = {
4e256731
EN
850 OPT_BOOL(0, "cone", &reapply_opts.cone_mode,
851 N_("initialize the sparse-checkout in cone mode")),
852 OPT_BOOL(0, "sparse-index", &reapply_opts.sparse_index,
853 N_("toggle the use of a sparse index")),
75d3bee1
JK
854 OPT_END(),
855 };
856
45c5e470
EN
857 if (!core_apply_sparse_checkout)
858 die(_("must be in a sparse-checkout to reapply sparsity patterns"));
859
f748012e
EN
860 reapply_opts.cone_mode = -1;
861 reapply_opts.sparse_index = -1;
862
ecd2d3ef 863 argc = parse_options(argc, argv, prefix,
75d3bee1
JK
864 builtin_sparse_checkout_reapply_options,
865 builtin_sparse_checkout_reapply_usage, 0);
866
5644ca28 867 repo_read_index(the_repository);
4e256731 868
4e256731
EN
869 if (update_modes(&reapply_opts.cone_mode, &reapply_opts.sparse_index))
870 return 1;
871
5644ca28
EN
872 return update_working_directory(NULL);
873}
874
75d3bee1 875static char const * const builtin_sparse_checkout_disable_usage[] = {
959d670d 876 "git sparse-checkout disable",
75d3bee1
JK
877 NULL
878};
879
1c3502b1
SG
880static int sparse_checkout_disable(int argc, const char **argv,
881 const char *prefix)
72918c1a 882{
75d3bee1
JK
883 static struct option builtin_sparse_checkout_disable_options[] = {
884 OPT_END(),
885 };
99dfa6f9
DS
886 struct pattern_list pl;
887 struct strbuf match_all = STRBUF_INIT;
72918c1a 888
45c5e470
EN
889 /*
890 * We do not exit early if !core_apply_sparse_checkout; due to the
891 * ability for users to manually muck things up between
892 * direct editing of .git/info/sparse-checkout
893 * running read-tree -m u HEAD or update-index --skip-worktree
894 * direct toggling of config options
895 * users might end up with an index with SKIP_WORKTREE bit set on
896 * some files and not know how to undo it. So, here we just
897 * forcibly return to a dense checkout regardless of initial state.
898 */
899
ecd2d3ef 900 argc = parse_options(argc, argv, prefix,
75d3bee1
JK
901 builtin_sparse_checkout_disable_options,
902 builtin_sparse_checkout_disable_usage, 0);
903
cff4e913 904 repo_read_index(the_repository);
cff4e913 905
99dfa6f9
DS
906 memset(&pl, 0, sizeof(pl));
907 hashmap_init(&pl.recursive_hashmap, pl_hashmap_cmp, NULL, 0);
908 hashmap_init(&pl.parent_hashmap, pl_hashmap_cmp, NULL, 0);
909 pl.use_cone_patterns = 0;
910 core_apply_sparse_checkout = 1;
72918c1a 911
99dfa6f9
DS
912 strbuf_addstr(&match_all, "/*");
913 add_pattern(strbuf_detach(&match_all, NULL), empty_base, 0, &pl, 0);
72918c1a 914
dcc5fd5f
DS
915 prepare_repo_settings(the_repository);
916 the_repository->settings.sparse_index = 0;
917
99dfa6f9 918 if (update_working_directory(&pl))
72918c1a
DS
919 die(_("error while refreshing working directory"));
920
99dfa6f9 921 clear_pattern_list(&pl);
72918c1a
DS
922 return set_config(MODE_NO_PATTERNS);
923}
924
94c0956b
DS
925int cmd_sparse_checkout(int argc, const char **argv, const char *prefix)
926{
1c3502b1
SG
927 parse_opt_subcommand_fn *fn = NULL;
928 struct option builtin_sparse_checkout_options[] = {
929 OPT_SUBCOMMAND("list", &fn, sparse_checkout_list),
930 OPT_SUBCOMMAND("init", &fn, sparse_checkout_init),
931 OPT_SUBCOMMAND("set", &fn, sparse_checkout_set),
932 OPT_SUBCOMMAND("add", &fn, sparse_checkout_add),
933 OPT_SUBCOMMAND("reapply", &fn, sparse_checkout_reapply),
934 OPT_SUBCOMMAND("disable", &fn, sparse_checkout_disable),
94c0956b
DS
935 OPT_END(),
936 };
937
94c0956b
DS
938 argc = parse_options(argc, argv, prefix,
939 builtin_sparse_checkout_options,
1c3502b1 940 builtin_sparse_checkout_usage, 0);
94c0956b
DS
941
942 git_config(git_default_config, NULL);
943
598b1e7d
DS
944 prepare_repo_settings(the_repository);
945 the_repository->settings.command_requires_full_index = 0;
946
1c3502b1 947 return fn(argc, argv, prefix);
94c0956b 948}