5 #include "parse-options.h"
7 #include "repository.h"
8 #include "run-command.h"
10 #include "string-list.h"
11 #include "cache-tree.h"
13 #include "resolve-undo.h"
14 #include "unpack-trees.h"
15 #include "wt-status.h"
17 #include "sparse-index.h"
20 static const char *empty_base
= "";
22 static char const * const builtin_sparse_checkout_usage
[] = {
23 N_("git sparse-checkout (init|list|set|add|reapply|disable) <options>"),
27 static void write_patterns_to_file(FILE *fp
, struct pattern_list
*pl
)
31 for (i
= 0; i
< pl
->nr
; i
++) {
32 struct path_pattern
*p
= pl
->patterns
[i
];
34 if (p
->flags
& PATTERN_FLAG_NEGATIVE
)
37 fprintf(fp
, "%s", p
->pattern
);
39 if (p
->flags
& PATTERN_FLAG_MUSTBEDIR
)
46 static char const * const builtin_sparse_checkout_list_usage
[] = {
47 "git sparse-checkout list",
51 static int sparse_checkout_list(int argc
, const char **argv
, const char *prefix
)
53 static struct option builtin_sparse_checkout_list_options
[] = {
56 struct pattern_list pl
;
57 char *sparse_filename
;
60 if (!core_apply_sparse_checkout
)
61 die(_("this worktree is not sparse"));
63 argc
= parse_options(argc
, argv
, prefix
,
64 builtin_sparse_checkout_list_options
,
65 builtin_sparse_checkout_list_usage
, 0);
67 memset(&pl
, 0, sizeof(pl
));
69 pl
.use_cone_patterns
= core_sparse_checkout_cone
;
71 sparse_filename
= get_sparse_checkout_filename();
72 res
= add_patterns_from_file_to_list(sparse_filename
, "", 0, &pl
, NULL
, 0);
73 free(sparse_filename
);
76 warning(_("this worktree is not sparse (sparse-checkout file may not exist)"));
80 if (pl
.use_cone_patterns
) {
82 struct pattern_entry
*pe
;
83 struct hashmap_iter iter
;
84 struct string_list sl
= STRING_LIST_INIT_DUP
;
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);
91 string_list_sort(&sl
);
93 for (i
= 0; i
< sl
.nr
; i
++) {
94 quote_c_style(sl
.items
[i
].string
, NULL
, stdout
, 0);
101 write_patterns_to_file(stdout
, &pl
);
102 clear_pattern_list(&pl
);
107 static void clean_tracked_sparse_directories(struct repository
*r
)
110 struct strbuf path
= STRBUF_INIT
;
112 struct string_list_item
*item
;
113 struct string_list sparse_dirs
= STRING_LIST_INIT_DUP
;
116 * If we are not using cone mode patterns, then we cannot
117 * delete directories outside of the sparse cone.
119 if (!r
|| !r
->index
|| !r
->worktree
)
121 if (init_sparse_checkout_patterns(r
->index
) ||
122 !r
->index
->sparse_checkout_patterns
->use_cone_patterns
)
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.
131 if (r
->index
->sparse_index
== INDEX_EXPANDED
) {
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.
137 if (convert_to_sparse(r
->index
, SPARSE_INDEX_MEMORY_ONLY
))
142 strbuf_addstr(&path
, r
->worktree
);
143 strbuf_complete(&path
, '/');
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.
152 for (i
= 0; i
< r
->index
->cache_nr
; i
++) {
153 struct cache_entry
*ce
= r
->index
->cache
[i
];
155 if (S_ISSPARSEDIR(ce
->ce_mode
) &&
156 repo_file_exists(r
, ce
->name
))
157 string_list_append(&sparse_dirs
, ce
->name
);
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
;
165 strbuf_setlen(&path
, pathlen
);
166 strbuf_addstr(&path
, item
->string
);
168 dir
.flags
|= DIR_SHOW_IGNORED_TOO
;
170 setup_standard_excludes(&dir
);
171 strvec_push(&s
, path
.buf
);
173 parse_pathspec(&p
, PATHSPEC_GLOB
, 0, NULL
, s
.v
);
174 fill_directory(&dir
, r
->index
, &p
);
177 warning(_("directory '%s' contains untracked files,"
178 " but is not in the sparse-checkout cone"),
180 } else if (remove_dir_recursively(&path
, 0)) {
182 * Removal is "best effort". If something blocks
183 * the deletion, then continue with a warning.
185 warning(_("failed to remove directory '%s'"),
194 string_list_clear(&sparse_dirs
, 0);
195 strbuf_release(&path
);
198 ensure_full_index(r
->index
);
201 static int update_working_directory(struct pattern_list
*pl
)
203 enum update_sparsity_result result
;
204 struct unpack_trees_options o
;
205 struct lock_file lock_file
= LOCK_INIT
;
206 struct repository
*r
= the_repository
;
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
;
212 r
->index
->sparse_checkout_patterns
= pl
;
214 memset(&o
, 0, sizeof(o
));
215 o
.verbose_update
= isatty(2);
218 o
.src_index
= r
->index
;
219 o
.dst_index
= r
->index
;
220 o
.skip_sparse_checkout
= 0;
225 repo_hold_locked_index(r
, &lock_file
, LOCK_DIE_ON_ERROR
);
227 setup_unpack_trees_porcelain(&o
, "sparse-checkout");
228 result
= update_sparsity(&o
);
229 clear_unpack_trees_porcelain(&o
);
231 if (result
== UPDATE_SPARSITY_WARNINGS
)
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.
236 result
= UPDATE_SPARSITY_SUCCESS
;
237 if (result
== UPDATE_SPARSITY_SUCCESS
)
238 write_locked_index(r
->index
, &lock_file
, COMMIT_LOCK
);
240 rollback_lock_file(&lock_file
);
242 clean_tracked_sparse_directories(r
);
244 r
->index
->sparse_checkout_patterns
= NULL
;
248 static char *escaped_pattern(char *pattern
)
251 struct strbuf final
= STRBUF_INIT
;
254 if (is_glob_special(*p
))
255 strbuf_addch(&final
, '\\');
257 strbuf_addch(&final
, *p
);
261 return strbuf_detach(&final
, NULL
);
264 static void write_cone_to_file(FILE *fp
, struct pattern_list
*pl
)
267 struct pattern_entry
*pe
;
268 struct hashmap_iter iter
;
269 struct string_list sl
= STRING_LIST_INIT_DUP
;
270 struct strbuf parent_pattern
= STRBUF_INIT
;
272 hashmap_for_each_entry(&pl
->parent_hashmap
, &iter
, pe
, ent
) {
273 if (hashmap_get_entry(&pl
->recursive_hashmap
, pe
, ent
, NULL
))
276 if (!hashmap_contains_parent(&pl
->recursive_hashmap
,
279 string_list_insert(&sl
, pe
->pattern
);
282 string_list_sort(&sl
);
283 string_list_remove_duplicates(&sl
, 0);
285 fprintf(fp
, "/*\n!/*/\n");
287 for (i
= 0; i
< sl
.nr
; i
++) {
288 char *pattern
= escaped_pattern(sl
.items
[i
].string
);
291 fprintf(fp
, "%s/\n!%s/*/\n", pattern
, pattern
);
295 string_list_clear(&sl
, 0);
297 hashmap_for_each_entry(&pl
->recursive_hashmap
, &iter
, pe
, ent
) {
298 if (!hashmap_contains_parent(&pl
->recursive_hashmap
,
301 string_list_insert(&sl
, pe
->pattern
);
304 strbuf_release(&parent_pattern
);
306 string_list_sort(&sl
);
307 string_list_remove_duplicates(&sl
, 0);
309 for (i
= 0; i
< sl
.nr
; i
++) {
310 char *pattern
= escaped_pattern(sl
.items
[i
].string
);
311 fprintf(fp
, "%s/\n", pattern
);
316 static int write_patterns_and_update(struct pattern_list
*pl
)
318 char *sparse_filename
;
321 struct lock_file lk
= LOCK_INIT
;
324 sparse_filename
= get_sparse_checkout_filename();
326 if (safe_create_leading_directories(sparse_filename
))
327 die(_("failed to create directory for sparse-checkout file"));
329 fd
= hold_lock_file_for_update(&lk
, sparse_filename
,
331 free(sparse_filename
);
333 result
= update_working_directory(pl
);
335 rollback_lock_file(&lk
);
336 clear_pattern_list(pl
);
337 update_working_directory(NULL
);
341 fp
= xfdopen(fd
, "w");
343 if (core_sparse_checkout_cone
)
344 write_cone_to_file(fp
, pl
);
346 write_patterns_to_file(fp
, pl
);
349 commit_lock_file(&lk
);
351 clear_pattern_list(pl
);
356 enum sparse_checkout_mode
{
357 MODE_NO_PATTERNS
= 0,
358 MODE_ALL_PATTERNS
= 1,
359 MODE_CONE_PATTERNS
= 2,
362 static int set_config(enum sparse_checkout_mode mode
)
364 /* Update to use worktree config, if not already. */
365 if (init_worktree_config(the_repository
)) {
366 error(_("failed to initialize worktree config"));
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
?
379 if (mode
== MODE_NO_PATTERNS
)
380 return set_sparse_index_config(the_repository
, 0);
385 static int update_modes(int *cone_mode
, int *sparse_index
)
387 int mode
, record_mode
;
389 /* Determine if we need to record the mode; ensure sparse checkout on */
390 record_mode
= (*cone_mode
!= -1) || !core_apply_sparse_checkout
;
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
;
396 /* Set cone/non-cone mode appropriately */
397 core_apply_sparse_checkout
= 1;
398 if (*cone_mode
== 1 || *cone_mode
== -1) {
399 mode
= MODE_CONE_PATTERNS
;
400 core_sparse_checkout_cone
= 1;
402 mode
= MODE_ALL_PATTERNS
;
403 core_sparse_checkout_cone
= 0;
405 if (record_mode
&& set_config(mode
))
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"));
413 /* force an index rewrite */
414 repo_read_index(the_repository
);
415 the_repository
->index
->updated_workdir
= 1;
418 ensure_full_index(the_repository
->index
);
424 static char const * const builtin_sparse_checkout_init_usage
[] = {
425 "git sparse-checkout init [--cone] [--[no-]sparse-index]",
429 static struct sparse_checkout_init_opts
{
434 static int sparse_checkout_init(int argc
, const char **argv
, const char *prefix
)
436 struct pattern_list pl
;
437 char *sparse_filename
;
439 struct object_id oid
;
440 struct strbuf pattern
= STRBUF_INIT
;
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")),
445 OPT_BOOL(0, "sparse-index", &init_opts
.sparse_index
,
446 N_("toggle the use of a sparse index")),
450 repo_read_index(the_repository
);
452 init_opts
.cone_mode
= -1;
453 init_opts
.sparse_index
= -1;
455 argc
= parse_options(argc
, argv
, prefix
,
456 builtin_sparse_checkout_init_options
,
457 builtin_sparse_checkout_init_usage
, 0);
459 if (update_modes(&init_opts
.cone_mode
, &init_opts
.sparse_index
))
462 memset(&pl
, 0, sizeof(pl
));
464 sparse_filename
= get_sparse_checkout_filename();
465 res
= add_patterns_from_file_to_list(sparse_filename
, "", 0, &pl
, NULL
, 0);
467 /* If we already have a sparse-checkout file, use it. */
469 free(sparse_filename
);
470 return update_working_directory(NULL
);
473 if (get_oid("HEAD", &oid
)) {
476 /* assume we are in a fresh repo, but update the sparse-checkout file */
477 if (safe_create_leading_directories(sparse_filename
))
478 die(_("unable to create leading directories of %s"),
480 fp
= xfopen(sparse_filename
, "w");
482 die(_("failed to open '%s'"), sparse_filename
);
484 free(sparse_filename
);
485 fprintf(fp
, "/*\n!/*/\n");
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);
494 pl
.use_cone_patterns
= init_opts
.cone_mode
;
496 return write_patterns_and_update(&pl
);
499 static void insert_recursive_pattern(struct pattern_list
*pl
, struct strbuf
*path
)
501 struct pattern_entry
*e
= xmalloc(sizeof(*e
));
502 e
->patternlen
= path
->len
;
503 e
->pattern
= strbuf_detach(path
, NULL
);
504 hashmap_entry_init(&e
->ent
, fspathhash(e
->pattern
));
506 hashmap_add(&pl
->recursive_hashmap
, &e
->ent
);
508 while (e
->patternlen
) {
509 char *slash
= strrchr(e
->pattern
, '/');
510 char *oldpattern
= e
->pattern
;
513 if (!slash
|| slash
== e
->pattern
)
516 newlen
= slash
- e
->pattern
;
517 e
= xmalloc(sizeof(struct pattern_entry
));
518 e
->patternlen
= newlen
;
519 e
->pattern
= xstrndup(oldpattern
, newlen
);
520 hashmap_entry_init(&e
->ent
, fspathhash(e
->pattern
));
522 if (!hashmap_get_entry(&pl
->parent_hashmap
, e
, ent
, NULL
))
523 hashmap_add(&pl
->parent_hashmap
, &e
->ent
);
527 static void strbuf_to_cone_pattern(struct strbuf
*line
, struct pattern_list
*pl
)
531 strbuf_trim_trailing_dir_sep(line
);
533 if (strbuf_normalize_path(line
))
534 die(_("could not normalize path %s"), line
->buf
);
539 if (line
->buf
[0] != '/')
540 strbuf_insertstr(line
, 0, "/");
542 insert_recursive_pattern(pl
, line
);
545 static void add_patterns_from_input(struct pattern_list
*pl
,
546 int argc
, const char **argv
,
550 if (core_sparse_checkout_cone
) {
551 struct strbuf line
= STRBUF_INIT
;
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;
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'"),
566 strbuf_swap(&unquoted
, &line
);
569 strbuf_to_cone_pattern(&line
, pl
);
572 strbuf_release(&unquoted
);
574 for (i
= 0; i
< argc
; i
++) {
575 strbuf_setlen(&line
, 0);
576 strbuf_addstr(&line
, argv
[i
]);
577 strbuf_to_cone_pattern(&line
, pl
);
582 struct strbuf line
= STRBUF_INIT
;
584 while (!strbuf_getline(&line
, stdin
)) {
586 char *buf
= strbuf_detach(&line
, &len
);
587 add_pattern(buf
, empty_base
, 0, pl
, 0);
590 for (i
= 0; i
< argc
; i
++)
591 add_pattern(argv
[i
], empty_base
, 0, pl
, 0);
601 static void add_patterns_cone_mode(int argc
, const char **argv
,
602 struct pattern_list
*pl
,
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();
611 add_patterns_from_input(pl
, argc
, argv
, use_stdin
);
613 memset(&existing
, 0, sizeof(existing
));
614 existing
.use_cone_patterns
= core_sparse_checkout_cone
;
616 if (add_patterns_from_file_to_list(sparse_filename
, "", 0,
618 die(_("unable to load existing sparse-checkout patterns"));
619 free(sparse_filename
);
621 if (!existing
.use_cone_patterns
)
622 die(_("existing sparse-checkout patterns do not use cone mode"));
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
);
635 clear_pattern_list(&existing
);
636 strbuf_release(&buffer
);
639 static void add_patterns_literal(int argc
, const char **argv
,
640 struct pattern_list
*pl
,
643 char *sparse_filename
= get_sparse_checkout_filename();
644 if (add_patterns_from_file_to_list(sparse_filename
, "", 0,
646 die(_("unable to load existing sparse-checkout patterns"));
647 free(sparse_filename
);
648 add_patterns_from_input(pl
, argc
, argv
, use_stdin
);
651 static int modify_pattern_list(int argc
, const char **argv
, int use_stdin
,
655 int changed_config
= 0;
656 struct pattern_list
*pl
= xcalloc(1, sizeof(*pl
));
660 if (core_sparse_checkout_cone
)
661 add_patterns_cone_mode(argc
, argv
, pl
, use_stdin
);
663 add_patterns_literal(argc
, argv
, pl
, use_stdin
);
667 add_patterns_from_input(pl
, argc
, argv
, use_stdin
);
671 if (!core_apply_sparse_checkout
) {
672 set_config(MODE_ALL_PATTERNS
);
673 core_apply_sparse_checkout
= 1;
677 result
= write_patterns_and_update(pl
);
679 if (result
&& changed_config
)
680 set_config(MODE_NO_PATTERNS
);
682 clear_pattern_list(pl
);
687 static void sanitize_paths(int argc
, const char **argv
,
688 const char *prefix
, int skip_checks
)
695 if (prefix
&& *prefix
&& core_sparse_checkout_cone
) {
697 * The args are not pathspecs, so unfortunately we
698 * cannot imitate how cmd_add() uses parse_pathspec().
700 int prefix_len
= strlen(prefix
);
702 for (i
= 0; i
< argc
; i
++)
703 argv
[i
] = prefix_path(prefix
, prefix_len
, argv
[i
]);
709 if (prefix
&& *prefix
&& !core_sparse_checkout_cone
)
710 die(_("please run from the toplevel directory in non-cone mode"));
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"));
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
]));
730 ce
= index
->cache
[pos
];
731 if (S_ISSPARSEDIR(ce
->ce_mode
))
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
]);
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
]);
741 static char const * const builtin_sparse_checkout_add_usage
[] = {
742 N_("git sparse-checkout add [--skip-checks] (--stdin | <patterns>)"),
746 static struct sparse_checkout_add_opts
{
751 static int sparse_checkout_add(int argc
, const char **argv
, const char *prefix
)
753 static struct option builtin_sparse_checkout_add_options
[] = {
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"),
757 OPT_BOOL(0, "stdin", &add_opts
.use_stdin
,
758 N_("read patterns from standard in")),
762 if (!core_apply_sparse_checkout
)
763 die(_("no sparse-checkout to add to"));
765 repo_read_index(the_repository
);
767 argc
= parse_options(argc
, argv
, prefix
,
768 builtin_sparse_checkout_add_options
,
769 builtin_sparse_checkout_add_usage
,
770 PARSE_OPT_KEEP_UNKNOWN_OPT
);
772 sanitize_paths(argc
, argv
, prefix
, add_opts
.skip_checks
);
774 return modify_pattern_list(argc
, argv
, add_opts
.use_stdin
, ADD
);
777 static char const * const builtin_sparse_checkout_set_usage
[] = {
778 N_("git sparse-checkout set [--[no-]cone] [--[no-]sparse-index] [--skip-checks] (--stdin | <patterns>)"),
782 static struct sparse_checkout_set_opts
{
789 static int sparse_checkout_set(int argc
, const char **argv
, const char *prefix
)
791 int default_patterns_nr
= 2;
792 const char *default_patterns
[] = {"/*", "!/*/", NULL
};
794 static struct option builtin_sparse_checkout_set_options
[] = {
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")),
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"),
802 OPT_BOOL_F(0, "stdin", &set_opts
.use_stdin
,
803 N_("read patterns from standard in"),
808 repo_read_index(the_repository
);
810 set_opts
.cone_mode
= -1;
811 set_opts
.sparse_index
= -1;
813 argc
= parse_options(argc
, argv
, prefix
,
814 builtin_sparse_checkout_set_options
,
815 builtin_sparse_checkout_set_usage
,
816 PARSE_OPT_KEEP_UNKNOWN_OPT
);
818 if (update_modes(&set_opts
.cone_mode
, &set_opts
.sparse_index
))
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).
826 if (!core_sparse_checkout_cone
&& argc
== 0) {
827 argv
= default_patterns
;
828 argc
= default_patterns_nr
;
830 sanitize_paths(argc
, argv
, prefix
, set_opts
.skip_checks
);
833 return modify_pattern_list(argc
, argv
, set_opts
.use_stdin
, REPLACE
);
836 static char const * const builtin_sparse_checkout_reapply_usage
[] = {
837 "git sparse-checkout reapply [--[no-]cone] [--[no-]sparse-index]",
841 static struct sparse_checkout_reapply_opts
{
846 static int sparse_checkout_reapply(int argc
, const char **argv
,
849 static struct option builtin_sparse_checkout_reapply_options
[] = {
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")),
857 if (!core_apply_sparse_checkout
)
858 die(_("must be in a sparse-checkout to reapply sparsity patterns"));
860 reapply_opts
.cone_mode
= -1;
861 reapply_opts
.sparse_index
= -1;
863 argc
= parse_options(argc
, argv
, prefix
,
864 builtin_sparse_checkout_reapply_options
,
865 builtin_sparse_checkout_reapply_usage
, 0);
867 repo_read_index(the_repository
);
869 if (update_modes(&reapply_opts
.cone_mode
, &reapply_opts
.sparse_index
))
872 return update_working_directory(NULL
);
875 static char const * const builtin_sparse_checkout_disable_usage
[] = {
876 "git sparse-checkout disable",
880 static int sparse_checkout_disable(int argc
, const char **argv
,
883 static struct option builtin_sparse_checkout_disable_options
[] = {
886 struct pattern_list pl
;
887 struct strbuf match_all
= STRBUF_INIT
;
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.
900 argc
= parse_options(argc
, argv
, prefix
,
901 builtin_sparse_checkout_disable_options
,
902 builtin_sparse_checkout_disable_usage
, 0);
904 repo_read_index(the_repository
);
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;
912 strbuf_addstr(&match_all
, "/*");
913 add_pattern(strbuf_detach(&match_all
, NULL
), empty_base
, 0, &pl
, 0);
915 prepare_repo_settings(the_repository
);
916 the_repository
->settings
.sparse_index
= 0;
918 if (update_working_directory(&pl
))
919 die(_("error while refreshing working directory"));
921 clear_pattern_list(&pl
);
922 return set_config(MODE_NO_PATTERNS
);
925 int cmd_sparse_checkout(int argc
, const char **argv
, const char *prefix
)
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
),
938 argc
= parse_options(argc
, argv
, prefix
,
939 builtin_sparse_checkout_options
,
940 builtin_sparse_checkout_usage
, 0);
942 git_config(git_default_config
, NULL
);
944 prepare_repo_settings(the_repository
);
945 the_repository
->settings
.command_requires_full_index
= 0;
947 return fn(argc
, argv
, prefix
);