#include "repository.h"
#include "run-command.h"
#include "strbuf.h"
+#include "string-list.h"
static char const * const builtin_sparse_checkout_usage[] = {
N_("git sparse-checkout (init|list|set|disable) <options>"),
enum sparse_checkout_mode {
MODE_NO_PATTERNS = 0,
MODE_ALL_PATTERNS = 1,
+ MODE_CONE_PATTERNS = 2,
};
static int sc_set_config(enum sparse_checkout_mode mode)
{
struct argv_array argv = ARGV_ARRAY_INIT;
+ struct argv_array cone_argv = ARGV_ARRAY_INIT;
if (git_config_set_gently("extensions.worktreeConfig", "true")) {
error(_("failed to set extensions.worktreeConfig setting"));
return 1;
}
+ argv_array_pushl(&cone_argv, "config", "--worktree",
+ "core.sparseCheckoutCone", NULL);
+
+ if (mode == MODE_CONE_PATTERNS)
+ argv_array_push(&cone_argv, "true");
+ else
+ argv_array_push(&cone_argv, "false");
+
+ if (run_command_v_opt(cone_argv.argv, RUN_GIT_CMD)) {
+ error(_("failed to enable core.sparseCheckoutCone"));
+ return 1;
+ }
+
return 0;
}
+static char const * const builtin_sparse_checkout_init_usage[] = {
+ N_("git sparse-checkout init [--cone]"),
+ NULL
+};
+
+static struct sparse_checkout_init_opts {
+ int cone_mode;
+} init_opts;
+
static int sparse_checkout_init(int argc, const char **argv)
{
struct pattern_list pl;
FILE *fp;
int res;
struct object_id oid;
+ int mode;
- if (sc_set_config(MODE_ALL_PATTERNS))
+ static struct option builtin_sparse_checkout_init_options[] = {
+ OPT_BOOL(0, "cone", &init_opts.cone_mode,
+ N_("initialize the sparse-checkout in cone mode")),
+ OPT_END(),
+ };
+
+ argc = parse_options(argc, argv, NULL,
+ builtin_sparse_checkout_init_options,
+ builtin_sparse_checkout_init_usage, 0);
+
+ mode = init_opts.cone_mode ? MODE_CONE_PATTERNS : MODE_ALL_PATTERNS;
+
+ if (sc_set_config(mode))
return 1;
memset(&pl, 0, sizeof(pl));
return update_working_directory();
}
+static void insert_recursive_pattern(struct pattern_list *pl, struct strbuf *path)
+{
+ struct pattern_entry *e = xmalloc(sizeof(*e));
+ e->patternlen = path->len;
+ e->pattern = strbuf_detach(path, NULL);
+ hashmap_entry_init(&e->ent, memhash(e->pattern, e->patternlen));
+
+ hashmap_add(&pl->recursive_hashmap, &e->ent);
+
+ while (e->patternlen) {
+ char *slash = strrchr(e->pattern, '/');
+ char *oldpattern = e->pattern;
+ size_t newlen;
+
+ if (slash == e->pattern)
+ break;
+
+ newlen = slash - e->pattern;
+ e = xmalloc(sizeof(struct pattern_entry));
+ e->patternlen = newlen;
+ e->pattern = xstrndup(oldpattern, newlen);
+ hashmap_entry_init(&e->ent, memhash(e->pattern, e->patternlen));
+
+ if (!hashmap_get_entry(&pl->parent_hashmap, e, ent, NULL))
+ hashmap_add(&pl->parent_hashmap, &e->ent);
+ }
+}
+
+static void write_cone_to_file(FILE *fp, struct pattern_list *pl)
+{
+ int i;
+ struct pattern_entry *pe;
+ struct hashmap_iter iter;
+ struct string_list sl = STRING_LIST_INIT_DUP;
+
+ hashmap_for_each_entry(&pl->parent_hashmap, &iter, pe, ent)
+ string_list_insert(&sl, pe->pattern);
+
+ string_list_sort(&sl);
+ string_list_remove_duplicates(&sl, 0);
+
+ fprintf(fp, "/*\n!/*/\n");
+
+ for (i = 0; i < sl.nr; i++) {
+ char *pattern = sl.items[i].string;
+
+ if (strlen(pattern))
+ fprintf(fp, "%s/\n!%s/*/\n", pattern, pattern);
+ }
+
+ string_list_clear(&sl, 0);
+
+ hashmap_for_each_entry(&pl->recursive_hashmap, &iter, pe, ent)
+ string_list_insert(&sl, pe->pattern);
+
+ string_list_sort(&sl);
+ string_list_remove_duplicates(&sl, 0);
+
+ for (i = 0; i < sl.nr; i++) {
+ char *pattern = sl.items[i].string;
+ fprintf(fp, "%s/\n", pattern);
+ }
+}
+
static int write_patterns_and_update(struct pattern_list *pl)
{
char *sparse_filename;
sparse_filename = get_sparse_checkout_filename();
fp = fopen(sparse_filename, "w");
- write_patterns_to_file(fp, pl);
+
+ if (core_sparse_checkout_cone)
+ write_cone_to_file(fp, pl);
+ else
+ write_patterns_to_file(fp, pl);
+
fclose(fp);
free(sparse_filename);
return update_working_directory();
}
+static void strbuf_to_cone_pattern(struct strbuf *line, struct pattern_list *pl)
+{
+ strbuf_trim(line);
+
+ strbuf_trim_trailing_dir_sep(line);
+
+ if (!line->len)
+ return;
+
+ if (line->buf[0] != '/')
+ strbuf_insert(line, 0, "/", 1);
+
+ insert_recursive_pattern(pl, line);
+}
+
static char const * const builtin_sparse_checkout_set_usage[] = {
N_("git sparse-checkout set [--stdin|<patterns>]"),
NULL
builtin_sparse_checkout_set_usage,
PARSE_OPT_KEEP_UNKNOWN);
- if (set_opts.use_stdin) {
+ if (core_sparse_checkout_cone) {
struct strbuf line = STRBUF_INIT;
-
- while (!strbuf_getline(&line, stdin)) {
- size_t len;
- char *buf = strbuf_detach(&line, &len);
- add_pattern(buf, empty_base, 0, &pl, 0);
+ hashmap_init(&pl.recursive_hashmap, pl_hashmap_cmp, NULL, 0);
+ hashmap_init(&pl.parent_hashmap, pl_hashmap_cmp, NULL, 0);
+
+ if (set_opts.use_stdin) {
+ while (!strbuf_getline(&line, stdin))
+ strbuf_to_cone_pattern(&line, &pl);
+ } else {
+ for (i = 0; i < argc; i++) {
+ strbuf_setlen(&line, 0);
+ strbuf_addstr(&line, argv[i]);
+ strbuf_to_cone_pattern(&line, &pl);
+ }
}
} else {
- for (i = 0; i < argc; i++)
- add_pattern(argv[i], empty_base, 0, &pl, 0);
+ if (set_opts.use_stdin) {
+ struct strbuf line = STRBUF_INIT;
+
+ while (!strbuf_getline(&line, stdin)) {
+ size_t len;
+ char *buf = strbuf_detach(&line, &len);
+ add_pattern(buf, empty_base, 0, &pl, 0);
+ }
+ } else {
+ for (i = 0; i < argc; i++)
+ add_pattern(argv[i], empty_base, 0, &pl, 0);
+ }
}
if (!core_apply_sparse_checkout) {