4 #include "parse-options.h"
6 #include "repository.h"
7 #include "run-command.h"
9 #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"
19 static const char *empty_base
= "";
21 static char const * const builtin_sparse_checkout_usage
[] = {
22 N_("git sparse-checkout (init|list|set|add|reapply|disable) <options>"),
26 static void write_patterns_to_file(FILE *fp
, struct pattern_list
*pl
)
30 for (i
= 0; i
< pl
->nr
; i
++) {
31 struct path_pattern
*p
= pl
->patterns
[i
];
33 if (p
->flags
& PATTERN_FLAG_NEGATIVE
)
36 fprintf(fp
, "%s", p
->pattern
);
38 if (p
->flags
& PATTERN_FLAG_MUSTBEDIR
)
45 static char const * const builtin_sparse_checkout_list_usage
[] = {
46 N_("git sparse-checkout list"),
50 static int sparse_checkout_list(int argc
, const char **argv
)
52 static struct option builtin_sparse_checkout_list_options
[] = {
55 struct pattern_list pl
;
56 char *sparse_filename
;
59 argc
= parse_options(argc
, argv
, NULL
,
60 builtin_sparse_checkout_list_options
,
61 builtin_sparse_checkout_list_usage
, 0);
63 memset(&pl
, 0, sizeof(pl
));
65 pl
.use_cone_patterns
= core_sparse_checkout_cone
;
67 sparse_filename
= get_sparse_checkout_filename();
68 res
= add_patterns_from_file_to_list(sparse_filename
, "", 0, &pl
, NULL
, 0);
69 free(sparse_filename
);
72 warning(_("this worktree is not sparse (sparse-checkout file may not exist)"));
76 if (pl
.use_cone_patterns
) {
78 struct pattern_entry
*pe
;
79 struct hashmap_iter iter
;
80 struct string_list sl
= STRING_LIST_INIT_DUP
;
82 hashmap_for_each_entry(&pl
.recursive_hashmap
, &iter
, pe
, ent
) {
83 /* pe->pattern starts with "/", skip it */
84 string_list_insert(&sl
, pe
->pattern
+ 1);
87 string_list_sort(&sl
);
89 for (i
= 0; i
< sl
.nr
; i
++) {
90 quote_c_style(sl
.items
[i
].string
, NULL
, stdout
, 0);
97 write_patterns_to_file(stdout
, &pl
);
98 clear_pattern_list(&pl
);
103 static int update_working_directory(struct pattern_list
*pl
)
105 enum update_sparsity_result result
;
106 struct unpack_trees_options o
;
107 struct lock_file lock_file
= LOCK_INIT
;
108 struct repository
*r
= the_repository
;
110 /* If no branch has been checked out, there are no updates to make. */
111 if (is_index_unborn(r
->index
))
112 return UPDATE_SPARSITY_SUCCESS
;
114 r
->index
->sparse_checkout_patterns
= pl
;
116 memset(&o
, 0, sizeof(o
));
117 o
.verbose_update
= isatty(2);
120 o
.src_index
= r
->index
;
121 o
.dst_index
= r
->index
;
122 o
.skip_sparse_checkout
= 0;
127 repo_hold_locked_index(r
, &lock_file
, LOCK_DIE_ON_ERROR
);
129 setup_unpack_trees_porcelain(&o
, "sparse-checkout");
130 result
= update_sparsity(&o
);
131 clear_unpack_trees_porcelain(&o
);
133 if (result
== UPDATE_SPARSITY_WARNINGS
)
135 * We don't do any special handling of warnings from untracked
136 * files in the way or dirty entries that can't be removed.
138 result
= UPDATE_SPARSITY_SUCCESS
;
139 if (result
== UPDATE_SPARSITY_SUCCESS
)
140 write_locked_index(r
->index
, &lock_file
, COMMIT_LOCK
);
142 rollback_lock_file(&lock_file
);
144 r
->index
->sparse_checkout_patterns
= NULL
;
148 static char *escaped_pattern(char *pattern
)
151 struct strbuf final
= STRBUF_INIT
;
154 if (is_glob_special(*p
))
155 strbuf_addch(&final
, '\\');
157 strbuf_addch(&final
, *p
);
161 return strbuf_detach(&final
, NULL
);
164 static void write_cone_to_file(FILE *fp
, struct pattern_list
*pl
)
167 struct pattern_entry
*pe
;
168 struct hashmap_iter iter
;
169 struct string_list sl
= STRING_LIST_INIT_DUP
;
170 struct strbuf parent_pattern
= STRBUF_INIT
;
172 hashmap_for_each_entry(&pl
->parent_hashmap
, &iter
, pe
, ent
) {
173 if (hashmap_get_entry(&pl
->recursive_hashmap
, pe
, ent
, NULL
))
176 if (!hashmap_contains_parent(&pl
->recursive_hashmap
,
179 string_list_insert(&sl
, pe
->pattern
);
182 string_list_sort(&sl
);
183 string_list_remove_duplicates(&sl
, 0);
185 fprintf(fp
, "/*\n!/*/\n");
187 for (i
= 0; i
< sl
.nr
; i
++) {
188 char *pattern
= escaped_pattern(sl
.items
[i
].string
);
191 fprintf(fp
, "%s/\n!%s/*/\n", pattern
, pattern
);
195 string_list_clear(&sl
, 0);
197 hashmap_for_each_entry(&pl
->recursive_hashmap
, &iter
, pe
, ent
) {
198 if (!hashmap_contains_parent(&pl
->recursive_hashmap
,
201 string_list_insert(&sl
, pe
->pattern
);
204 strbuf_release(&parent_pattern
);
206 string_list_sort(&sl
);
207 string_list_remove_duplicates(&sl
, 0);
209 for (i
= 0; i
< sl
.nr
; i
++) {
210 char *pattern
= escaped_pattern(sl
.items
[i
].string
);
211 fprintf(fp
, "%s/\n", pattern
);
216 static int write_patterns_and_update(struct pattern_list
*pl
)
218 char *sparse_filename
;
221 struct lock_file lk
= LOCK_INIT
;
224 sparse_filename
= get_sparse_checkout_filename();
226 if (safe_create_leading_directories(sparse_filename
))
227 die(_("failed to create directory for sparse-checkout file"));
229 fd
= hold_lock_file_for_update(&lk
, sparse_filename
,
232 result
= update_working_directory(pl
);
234 rollback_lock_file(&lk
);
235 free(sparse_filename
);
236 clear_pattern_list(pl
);
237 update_working_directory(NULL
);
241 fp
= xfdopen(fd
, "w");
243 if (core_sparse_checkout_cone
)
244 write_cone_to_file(fp
, pl
);
246 write_patterns_to_file(fp
, pl
);
249 commit_lock_file(&lk
);
251 free(sparse_filename
);
252 clear_pattern_list(pl
);
257 enum sparse_checkout_mode
{
258 MODE_NO_PATTERNS
= 0,
259 MODE_ALL_PATTERNS
= 1,
260 MODE_CONE_PATTERNS
= 2,
263 static int set_config(enum sparse_checkout_mode mode
)
265 const char *config_path
;
267 if (upgrade_repository_format(1) < 0)
268 die(_("unable to upgrade repository format to enable worktreeConfig"));
269 if (git_config_set_gently("extensions.worktreeConfig", "true")) {
270 error(_("failed to set extensions.worktreeConfig setting"));
274 config_path
= git_path("config.worktree");
275 git_config_set_in_file_gently(config_path
,
276 "core.sparseCheckout",
277 mode
? "true" : NULL
);
279 git_config_set_in_file_gently(config_path
,
280 "core.sparseCheckoutCone",
281 mode
== MODE_CONE_PATTERNS
? "true" : NULL
);
283 if (mode
== MODE_NO_PATTERNS
)
284 set_sparse_index_config(the_repository
, 0);
289 static char const * const builtin_sparse_checkout_init_usage
[] = {
290 N_("git sparse-checkout init [--cone] [--[no-]sparse-index]"),
294 static struct sparse_checkout_init_opts
{
299 static int sparse_checkout_init(int argc
, const char **argv
)
301 struct pattern_list pl
;
302 char *sparse_filename
;
304 struct object_id oid
;
306 struct strbuf pattern
= STRBUF_INIT
;
308 static struct option builtin_sparse_checkout_init_options
[] = {
309 OPT_BOOL(0, "cone", &init_opts
.cone_mode
,
310 N_("initialize the sparse-checkout in cone mode")),
311 OPT_BOOL(0, "sparse-index", &init_opts
.sparse_index
,
312 N_("toggle the use of a sparse index")),
316 repo_read_index(the_repository
);
318 init_opts
.sparse_index
= -1;
320 argc
= parse_options(argc
, argv
, NULL
,
321 builtin_sparse_checkout_init_options
,
322 builtin_sparse_checkout_init_usage
, 0);
324 if (init_opts
.cone_mode
) {
325 mode
= MODE_CONE_PATTERNS
;
326 core_sparse_checkout_cone
= 1;
328 mode
= MODE_ALL_PATTERNS
;
330 if (set_config(mode
))
333 memset(&pl
, 0, sizeof(pl
));
335 sparse_filename
= get_sparse_checkout_filename();
336 res
= add_patterns_from_file_to_list(sparse_filename
, "", 0, &pl
, NULL
, 0);
338 if (init_opts
.sparse_index
>= 0) {
339 if (set_sparse_index_config(the_repository
, init_opts
.sparse_index
) < 0)
340 die(_("failed to modify sparse-index config"));
342 /* force an index rewrite */
343 repo_read_index(the_repository
);
344 the_repository
->index
->updated_workdir
= 1;
347 core_apply_sparse_checkout
= 1;
349 /* If we already have a sparse-checkout file, use it. */
351 free(sparse_filename
);
352 return update_working_directory(NULL
);
355 if (get_oid("HEAD", &oid
)) {
358 /* assume we are in a fresh repo, but update the sparse-checkout file */
359 fp
= xfopen(sparse_filename
, "w");
361 die(_("failed to open '%s'"), sparse_filename
);
363 free(sparse_filename
);
364 fprintf(fp
, "/*\n!/*/\n");
369 strbuf_addstr(&pattern
, "/*");
370 add_pattern(strbuf_detach(&pattern
, NULL
), empty_base
, 0, &pl
, 0);
371 strbuf_addstr(&pattern
, "!/*/");
372 add_pattern(strbuf_detach(&pattern
, NULL
), empty_base
, 0, &pl
, 0);
373 pl
.use_cone_patterns
= init_opts
.cone_mode
;
375 return write_patterns_and_update(&pl
);
378 static void insert_recursive_pattern(struct pattern_list
*pl
, struct strbuf
*path
)
380 struct pattern_entry
*e
= xmalloc(sizeof(*e
));
381 e
->patternlen
= path
->len
;
382 e
->pattern
= strbuf_detach(path
, NULL
);
383 hashmap_entry_init(&e
->ent
,
385 strihash(e
->pattern
) :
386 strhash(e
->pattern
));
388 hashmap_add(&pl
->recursive_hashmap
, &e
->ent
);
390 while (e
->patternlen
) {
391 char *slash
= strrchr(e
->pattern
, '/');
392 char *oldpattern
= e
->pattern
;
395 if (slash
== e
->pattern
)
398 newlen
= slash
- e
->pattern
;
399 e
= xmalloc(sizeof(struct pattern_entry
));
400 e
->patternlen
= newlen
;
401 e
->pattern
= xstrndup(oldpattern
, newlen
);
402 hashmap_entry_init(&e
->ent
,
404 strihash(e
->pattern
) :
405 strhash(e
->pattern
));
407 if (!hashmap_get_entry(&pl
->parent_hashmap
, e
, ent
, NULL
))
408 hashmap_add(&pl
->parent_hashmap
, &e
->ent
);
412 static void strbuf_to_cone_pattern(struct strbuf
*line
, struct pattern_list
*pl
)
416 strbuf_trim_trailing_dir_sep(line
);
418 if (strbuf_normalize_path(line
))
419 die(_("could not normalize path %s"), line
->buf
);
424 if (line
->buf
[0] != '/')
425 strbuf_insertstr(line
, 0, "/");
427 insert_recursive_pattern(pl
, line
);
430 static char const * const builtin_sparse_checkout_set_usage
[] = {
431 N_("git sparse-checkout (set|add) (--stdin | <patterns>)"),
435 static struct sparse_checkout_set_opts
{
439 static void add_patterns_from_input(struct pattern_list
*pl
,
440 int argc
, const char **argv
)
443 if (core_sparse_checkout_cone
) {
444 struct strbuf line
= STRBUF_INIT
;
446 hashmap_init(&pl
->recursive_hashmap
, pl_hashmap_cmp
, NULL
, 0);
447 hashmap_init(&pl
->parent_hashmap
, pl_hashmap_cmp
, NULL
, 0);
448 pl
->use_cone_patterns
= 1;
450 if (set_opts
.use_stdin
) {
451 struct strbuf unquoted
= STRBUF_INIT
;
452 while (!strbuf_getline(&line
, stdin
)) {
453 if (line
.buf
[0] == '"') {
454 strbuf_reset(&unquoted
);
455 if (unquote_c_style(&unquoted
, line
.buf
, NULL
))
456 die(_("unable to unquote C-style string '%s'"),
459 strbuf_swap(&unquoted
, &line
);
462 strbuf_to_cone_pattern(&line
, pl
);
465 strbuf_release(&unquoted
);
467 for (i
= 0; i
< argc
; i
++) {
468 strbuf_setlen(&line
, 0);
469 strbuf_addstr(&line
, argv
[i
]);
470 strbuf_to_cone_pattern(&line
, pl
);
474 if (set_opts
.use_stdin
) {
475 struct strbuf line
= STRBUF_INIT
;
477 while (!strbuf_getline(&line
, stdin
)) {
479 char *buf
= strbuf_detach(&line
, &len
);
480 add_pattern(buf
, empty_base
, 0, pl
, 0);
483 for (i
= 0; i
< argc
; i
++)
484 add_pattern(argv
[i
], empty_base
, 0, pl
, 0);
494 static void add_patterns_cone_mode(int argc
, const char **argv
,
495 struct pattern_list
*pl
)
497 struct strbuf buffer
= STRBUF_INIT
;
498 struct pattern_entry
*pe
;
499 struct hashmap_iter iter
;
500 struct pattern_list existing
;
501 char *sparse_filename
= get_sparse_checkout_filename();
503 add_patterns_from_input(pl
, argc
, argv
);
505 memset(&existing
, 0, sizeof(existing
));
506 existing
.use_cone_patterns
= core_sparse_checkout_cone
;
508 if (add_patterns_from_file_to_list(sparse_filename
, "", 0,
510 die(_("unable to load existing sparse-checkout patterns"));
511 free(sparse_filename
);
513 hashmap_for_each_entry(&existing
.recursive_hashmap
, &iter
, pe
, ent
) {
514 if (!hashmap_contains_parent(&pl
->recursive_hashmap
,
515 pe
->pattern
, &buffer
) ||
516 !hashmap_contains_parent(&pl
->parent_hashmap
,
517 pe
->pattern
, &buffer
)) {
518 strbuf_reset(&buffer
);
519 strbuf_addstr(&buffer
, pe
->pattern
);
520 insert_recursive_pattern(pl
, &buffer
);
524 clear_pattern_list(&existing
);
525 strbuf_release(&buffer
);
528 static void add_patterns_literal(int argc
, const char **argv
,
529 struct pattern_list
*pl
)
531 char *sparse_filename
= get_sparse_checkout_filename();
532 if (add_patterns_from_file_to_list(sparse_filename
, "", 0,
534 die(_("unable to load existing sparse-checkout patterns"));
535 free(sparse_filename
);
536 add_patterns_from_input(pl
, argc
, argv
);
539 static int modify_pattern_list(int argc
, const char **argv
, enum modify_type m
)
542 int changed_config
= 0;
543 struct pattern_list
*pl
= xcalloc(1, sizeof(*pl
));
547 if (core_sparse_checkout_cone
)
548 add_patterns_cone_mode(argc
, argv
, pl
);
550 add_patterns_literal(argc
, argv
, pl
);
554 add_patterns_from_input(pl
, argc
, argv
);
558 if (!core_apply_sparse_checkout
) {
559 set_config(MODE_ALL_PATTERNS
);
560 core_apply_sparse_checkout
= 1;
564 result
= write_patterns_and_update(pl
);
566 if (result
&& changed_config
)
567 set_config(MODE_NO_PATTERNS
);
569 clear_pattern_list(pl
);
574 static int sparse_checkout_set(int argc
, const char **argv
, const char *prefix
,
577 static struct option builtin_sparse_checkout_set_options
[] = {
578 OPT_BOOL(0, "stdin", &set_opts
.use_stdin
,
579 N_("read patterns from standard in")),
583 repo_read_index(the_repository
);
585 argc
= parse_options(argc
, argv
, prefix
,
586 builtin_sparse_checkout_set_options
,
587 builtin_sparse_checkout_set_usage
,
588 PARSE_OPT_KEEP_UNKNOWN
);
590 return modify_pattern_list(argc
, argv
, m
);
593 static char const * const builtin_sparse_checkout_reapply_usage
[] = {
594 N_("git sparse-checkout reapply"),
598 static int sparse_checkout_reapply(int argc
, const char **argv
)
600 static struct option builtin_sparse_checkout_reapply_options
[] = {
604 argc
= parse_options(argc
, argv
, NULL
,
605 builtin_sparse_checkout_reapply_options
,
606 builtin_sparse_checkout_reapply_usage
, 0);
608 repo_read_index(the_repository
);
609 return update_working_directory(NULL
);
612 static char const * const builtin_sparse_checkout_disable_usage
[] = {
613 N_("git sparse-checkout disable"),
617 static int sparse_checkout_disable(int argc
, const char **argv
)
619 static struct option builtin_sparse_checkout_disable_options
[] = {
622 struct pattern_list pl
;
623 struct strbuf match_all
= STRBUF_INIT
;
625 argc
= parse_options(argc
, argv
, NULL
,
626 builtin_sparse_checkout_disable_options
,
627 builtin_sparse_checkout_disable_usage
, 0);
629 repo_read_index(the_repository
);
631 memset(&pl
, 0, sizeof(pl
));
632 hashmap_init(&pl
.recursive_hashmap
, pl_hashmap_cmp
, NULL
, 0);
633 hashmap_init(&pl
.parent_hashmap
, pl_hashmap_cmp
, NULL
, 0);
634 pl
.use_cone_patterns
= 0;
635 core_apply_sparse_checkout
= 1;
637 strbuf_addstr(&match_all
, "/*");
638 add_pattern(strbuf_detach(&match_all
, NULL
), empty_base
, 0, &pl
, 0);
640 prepare_repo_settings(the_repository
);
641 the_repository
->settings
.sparse_index
= 0;
643 if (update_working_directory(&pl
))
644 die(_("error while refreshing working directory"));
646 clear_pattern_list(&pl
);
647 return set_config(MODE_NO_PATTERNS
);
650 int cmd_sparse_checkout(int argc
, const char **argv
, const char *prefix
)
652 static struct option builtin_sparse_checkout_options
[] = {
656 if (argc
== 2 && !strcmp(argv
[1], "-h"))
657 usage_with_options(builtin_sparse_checkout_usage
,
658 builtin_sparse_checkout_options
);
660 argc
= parse_options(argc
, argv
, prefix
,
661 builtin_sparse_checkout_options
,
662 builtin_sparse_checkout_usage
,
663 PARSE_OPT_STOP_AT_NON_OPTION
);
665 git_config(git_default_config
, NULL
);
668 if (!strcmp(argv
[0], "list"))
669 return sparse_checkout_list(argc
, argv
);
670 if (!strcmp(argv
[0], "init"))
671 return sparse_checkout_init(argc
, argv
);
672 if (!strcmp(argv
[0], "set"))
673 return sparse_checkout_set(argc
, argv
, prefix
, REPLACE
);
674 if (!strcmp(argv
[0], "add"))
675 return sparse_checkout_set(argc
, argv
, prefix
, ADD
);
676 if (!strcmp(argv
[0], "reapply"))
677 return sparse_checkout_reapply(argc
, argv
);
678 if (!strcmp(argv
[0], "disable"))
679 return sparse_checkout_disable(argc
, argv
);
682 usage_with_options(builtin_sparse_checkout_usage
,
683 builtin_sparse_checkout_options
);