2019-11-21 22:04:33 +00:00
|
|
|
#include "builtin.h"
|
|
|
|
#include "config.h"
|
|
|
|
#include "dir.h"
|
|
|
|
#include "parse-options.h"
|
|
|
|
#include "pathspec.h"
|
|
|
|
#include "repository.h"
|
|
|
|
#include "run-command.h"
|
|
|
|
#include "strbuf.h"
|
2019-11-21 22:04:42 +00:00
|
|
|
#include "string-list.h"
|
2019-11-21 22:04:46 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "cache-tree.h"
|
|
|
|
#include "lockfile.h"
|
|
|
|
#include "resolve-undo.h"
|
|
|
|
#include "unpack-trees.h"
|
2019-11-21 22:04:51 +00:00
|
|
|
#include "wt-status.h"
|
2020-01-31 20:16:10 +00:00
|
|
|
#include "quote.h"
|
2019-11-21 22:04:33 +00:00
|
|
|
|
2019-11-21 22:04:50 +00:00
|
|
|
static const char *empty_base = "";
|
|
|
|
|
2019-11-21 22:04:33 +00:00
|
|
|
static char const * const builtin_sparse_checkout_usage[] = {
|
2020-03-27 00:49:01 +00:00
|
|
|
N_("git sparse-checkout (init|list|set|add|reapply|disable) <options>"),
|
2019-11-21 22:04:33 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static char *get_sparse_checkout_filename(void)
|
|
|
|
{
|
|
|
|
return git_pathdup("info/sparse-checkout");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void write_patterns_to_file(FILE *fp, struct pattern_list *pl)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < pl->nr; i++) {
|
|
|
|
struct path_pattern *p = pl->patterns[i];
|
|
|
|
|
|
|
|
if (p->flags & PATTERN_FLAG_NEGATIVE)
|
|
|
|
fprintf(fp, "!");
|
|
|
|
|
|
|
|
fprintf(fp, "%s", p->pattern);
|
|
|
|
|
|
|
|
if (p->flags & PATTERN_FLAG_MUSTBEDIR)
|
|
|
|
fprintf(fp, "/");
|
|
|
|
|
|
|
|
fprintf(fp, "\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-30 12:30:10 +00:00
|
|
|
static char const * const builtin_sparse_checkout_list_usage[] = {
|
|
|
|
N_("git sparse-checkout list"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2019-11-21 22:04:33 +00:00
|
|
|
static int sparse_checkout_list(int argc, const char **argv)
|
|
|
|
{
|
2020-09-30 12:30:10 +00:00
|
|
|
static struct option builtin_sparse_checkout_list_options[] = {
|
|
|
|
OPT_END(),
|
|
|
|
};
|
2019-11-21 22:04:33 +00:00
|
|
|
struct pattern_list pl;
|
|
|
|
char *sparse_filename;
|
|
|
|
int res;
|
|
|
|
|
2020-09-30 12:30:10 +00:00
|
|
|
argc = parse_options(argc, argv, NULL,
|
|
|
|
builtin_sparse_checkout_list_options,
|
|
|
|
builtin_sparse_checkout_list_usage, 0);
|
|
|
|
|
2019-11-21 22:04:33 +00:00
|
|
|
memset(&pl, 0, sizeof(pl));
|
|
|
|
|
2019-12-30 15:33:12 +00:00
|
|
|
pl.use_cone_patterns = core_sparse_checkout_cone;
|
|
|
|
|
2019-11-21 22:04:33 +00:00
|
|
|
sparse_filename = get_sparse_checkout_filename();
|
|
|
|
res = add_patterns_from_file_to_list(sparse_filename, "", 0, &pl, NULL);
|
|
|
|
free(sparse_filename);
|
|
|
|
|
|
|
|
if (res < 0) {
|
|
|
|
warning(_("this worktree is not sparse (sparse-checkout file may not exist)"));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-12-30 15:33:12 +00:00
|
|
|
if (pl.use_cone_patterns) {
|
|
|
|
int i;
|
|
|
|
struct pattern_entry *pe;
|
|
|
|
struct hashmap_iter iter;
|
|
|
|
struct string_list sl = STRING_LIST_INIT_DUP;
|
|
|
|
|
|
|
|
hashmap_for_each_entry(&pl.recursive_hashmap, &iter, pe, ent) {
|
|
|
|
/* pe->pattern starts with "/", skip it */
|
|
|
|
string_list_insert(&sl, pe->pattern + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
string_list_sort(&sl);
|
|
|
|
|
2020-01-31 20:16:12 +00:00
|
|
|
for (i = 0; i < sl.nr; i++) {
|
|
|
|
quote_c_style(sl.items[i].string, NULL, stdout, 0);
|
|
|
|
printf("\n");
|
|
|
|
}
|
2019-12-30 15:33:12 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-11-21 22:04:33 +00:00
|
|
|
write_patterns_to_file(stdout, &pl);
|
|
|
|
clear_pattern_list(&pl);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-11-21 22:04:46 +00:00
|
|
|
static int update_working_directory(struct pattern_list *pl)
|
2019-11-21 22:04:34 +00:00
|
|
|
{
|
2020-03-27 00:48:53 +00:00
|
|
|
enum update_sparsity_result result;
|
2019-11-21 22:04:46 +00:00
|
|
|
struct unpack_trees_options o;
|
|
|
|
struct lock_file lock_file = LOCK_INIT;
|
|
|
|
struct repository *r = the_repository;
|
2019-11-21 22:04:34 +00:00
|
|
|
|
sparse-checkout: avoid staging deletions of all files
sparse-checkout's purpose is to update the working tree to have it
reflect a subset of the tracked files. As such, it shouldn't be
switching branches, making commits, downloading or uploading data, or
staging or unstaging changes. Other than updating the worktree, the
only thing sparse-checkout should touch is the SKIP_WORKTREE bit of the
index. In particular, this sets up a nice invariant: running
sparse-checkout will never change the status of any file in `git status`
(reflecting the fact that we only set the SKIP_WORKTREE bit if the file
is safe to delete, i.e. if the file is unmodified).
Traditionally, we did a _really_ bad job with this goal. The
predecessor to sparse-checkout involved manual editing of
.git/info/sparse-checkout and running `git read-tree -mu HEAD`. That
command would stage and unstage changes and overwrite dirty changes in
the working tree.
The initial implementation of the sparse-checkout command was no better;
it simply invoked `git read-tree -mu HEAD` as a subprocess and had the
same caveats, though this issue came up repeatedly in review comments
and workarounds for the problems were put in place before the feature
was merged[1, 2, 3, 4, 5, 6; especially see 4 & 6].
[1] https://lore.kernel.org/git/CABPp-BFT9A5n=_bx5LsjCvbogqwSjiwgr5amcjgbU1iAk4KLJg@mail.gmail.com/
[2] https://lore.kernel.org/git/CABPp-BEmwSwg4tgJg6nVG8a3Hpn_g-=ZjApZF4EiJO+qVgu4uw@mail.gmail.com/
[3] https://lore.kernel.org/git/CABPp-BFV7TA0qwZCQpHCqx9N+JifyRyuBQ-pZ_oGfe-NOgyh7A@mail.gmail.com/
[4] https://lore.kernel.org/git/CABPp-BHYCCD+Vx5fq35jH82eHc1-P53Lz_aGNpHJNcx9kg2K-A@mail.gmail.com/
[5] https://lore.kernel.org/git/CABPp-BF+JWYZfDqp2Tn4AEKVp4b0YMA=Mbz4Nz62D-gGgiduYQ@mail.gmail.com/
[6] https://lore.kernel.org/git/20191121163706.GV23183@szeder.dev/
However, these workarounds, in addition to disabling the feature in a
number of important cases, also missed one special case. I'll get back
to it later.
In the 2.27.0 cycle, the disabling of the feature was lifted by finally
replacing the internal equivalent of `git read-tree -mu HEAD` with
something that did what we wanted: the new update_sparsity() function in
unpack-trees.c that only ever updates SKIP_WORKTREE bits in the index
and updates the working tree to match. This new function handles all
the cases that were problematic for the old implementation, except that
it breaks the same special case that avoided the workarounds of the old
implementation, but broke it in a different way.
So...that brings us to the special case: a git clone performed with
--no-checkout. As per the meaning of the flag, --no-checkout does not
check out any branch, with the implication that you aren't on one and
need to switch to one after the clone. Implementationally, HEAD is
still set (so in some sense you are partially on a branch), but
* the index is "unborn" (non-existent)
* there are no files in the working tree (other than .git/)
* the next time git switch (or git checkout) is run it will run
unpack_trees with `initial_checkout` flag set to true.
It is not until you run, e.g. `git switch <somebranch>` that the index
will be written and files in the working tree populated.
With this special --no-checkout case, the traditional `read-tree -mu
HEAD` behavior would have done the equivalent of acting like checkout --
switch to the default branch (HEAD), write out an index that matches
HEAD, and update the working tree to match. This special case slipped
through the avoid-making-changes checks in the original sparse-checkout
command and thus continued there.
After update_sparsity() was introduced and used (see commit f56f31af03
("sparse-checkout: use new update_sparsity() function", 2020-03-27)),
the behavior for the --no-checkout case changed: Due to git's
auto-vivification of an empty in-memory index (see do_read_index() and
note that `must_exist` is false), and due to sparse-checkout's
update_working_directory() code to always write out the index after it
was done, we got a new bug. That made it so that sparse-checkout would
switch the repository from a clone with an "unborn" index (i.e. still
needing an initial_checkout), to one that had a recorded index with no
entries. Thus, instead of all the files appearing deleted in `git
status` being known to git as a special artifact of not yet being on a
branch, our recording of an empty index made it suddenly look to git as
though it was definitely on a branch with ALL files staged for deletion!
A subsequent checkout or switch then had to contend with the fact that
it wasn't on an initial_checkout but had a bunch of staged deletions.
Make sure that sparse-checkout changes nothing in the index other than
the SKIP_WORKTREE bit; in particular, when the index is unborn we do not
have any branch checked out so there is no sparsification or
de-sparsification work to do. Simply return from
update_working_directory() early.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-06-05 02:41:39 +00:00
|
|
|
/* If no branch has been checked out, there are no updates to make. */
|
|
|
|
if (is_index_unborn(r->index))
|
|
|
|
return UPDATE_SPARSITY_SUCCESS;
|
|
|
|
|
2019-11-21 22:04:46 +00:00
|
|
|
memset(&o, 0, sizeof(o));
|
|
|
|
o.verbose_update = isatty(2);
|
|
|
|
o.update = 1;
|
|
|
|
o.head_idx = -1;
|
|
|
|
o.src_index = r->index;
|
|
|
|
o.dst_index = r->index;
|
|
|
|
o.skip_sparse_checkout = 0;
|
|
|
|
o.pl = pl;
|
|
|
|
|
|
|
|
setup_work_tree();
|
|
|
|
|
|
|
|
repo_hold_locked_index(r, &lock_file, LOCK_DIE_ON_ERROR);
|
|
|
|
|
2020-03-27 00:48:54 +00:00
|
|
|
setup_unpack_trees_porcelain(&o, "sparse-checkout");
|
2020-03-27 00:48:53 +00:00
|
|
|
result = update_sparsity(&o);
|
2020-03-27 00:48:54 +00:00
|
|
|
clear_unpack_trees_porcelain(&o);
|
2019-11-21 22:04:46 +00:00
|
|
|
|
2020-03-27 00:48:53 +00:00
|
|
|
if (result == UPDATE_SPARSITY_WARNINGS)
|
|
|
|
/*
|
|
|
|
* We don't do any special handling of warnings from untracked
|
|
|
|
* files in the way or dirty entries that can't be removed.
|
|
|
|
*/
|
|
|
|
result = UPDATE_SPARSITY_SUCCESS;
|
|
|
|
if (result == UPDATE_SPARSITY_SUCCESS)
|
2019-11-21 22:04:46 +00:00
|
|
|
write_locked_index(r->index, &lock_file, COMMIT_LOCK);
|
2020-03-27 00:48:53 +00:00
|
|
|
else
|
2019-11-21 22:04:46 +00:00
|
|
|
rollback_lock_file(&lock_file);
|
2019-11-21 22:04:34 +00:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2020-01-31 20:16:10 +00:00
|
|
|
static char *escaped_pattern(char *pattern)
|
|
|
|
{
|
|
|
|
char *p = pattern;
|
|
|
|
struct strbuf final = STRBUF_INIT;
|
|
|
|
|
|
|
|
while (*p) {
|
2020-01-31 20:16:13 +00:00
|
|
|
if (is_glob_special(*p))
|
2020-01-31 20:16:10 +00:00
|
|
|
strbuf_addch(&final, '\\');
|
|
|
|
|
|
|
|
strbuf_addch(&final, *p);
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return strbuf_detach(&final, NULL);
|
|
|
|
}
|
|
|
|
|
2019-11-21 22:04:42 +00:00
|
|
|
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;
|
2019-11-21 22:04:45 +00:00
|
|
|
struct strbuf parent_pattern = STRBUF_INIT;
|
2019-11-21 22:04:42 +00:00
|
|
|
|
2019-11-21 22:04:45 +00:00
|
|
|
hashmap_for_each_entry(&pl->parent_hashmap, &iter, pe, ent) {
|
|
|
|
if (hashmap_get_entry(&pl->recursive_hashmap, pe, ent, NULL))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!hashmap_contains_parent(&pl->recursive_hashmap,
|
|
|
|
pe->pattern,
|
|
|
|
&parent_pattern))
|
|
|
|
string_list_insert(&sl, pe->pattern);
|
|
|
|
}
|
2019-11-21 22:04:42 +00:00
|
|
|
|
|
|
|
string_list_sort(&sl);
|
|
|
|
string_list_remove_duplicates(&sl, 0);
|
|
|
|
|
|
|
|
fprintf(fp, "/*\n!/*/\n");
|
|
|
|
|
|
|
|
for (i = 0; i < sl.nr; i++) {
|
2020-01-31 20:16:10 +00:00
|
|
|
char *pattern = escaped_pattern(sl.items[i].string);
|
2019-11-21 22:04:42 +00:00
|
|
|
|
|
|
|
if (strlen(pattern))
|
|
|
|
fprintf(fp, "%s/\n!%s/*/\n", pattern, pattern);
|
2020-01-31 20:16:10 +00:00
|
|
|
free(pattern);
|
2019-11-21 22:04:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
string_list_clear(&sl, 0);
|
|
|
|
|
2019-11-21 22:04:45 +00:00
|
|
|
hashmap_for_each_entry(&pl->recursive_hashmap, &iter, pe, ent) {
|
|
|
|
if (!hashmap_contains_parent(&pl->recursive_hashmap,
|
|
|
|
pe->pattern,
|
|
|
|
&parent_pattern))
|
|
|
|
string_list_insert(&sl, pe->pattern);
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_release(&parent_pattern);
|
2019-11-21 22:04:42 +00:00
|
|
|
|
|
|
|
string_list_sort(&sl);
|
|
|
|
string_list_remove_duplicates(&sl, 0);
|
|
|
|
|
|
|
|
for (i = 0; i < sl.nr; i++) {
|
2020-01-31 20:16:10 +00:00
|
|
|
char *pattern = escaped_pattern(sl.items[i].string);
|
2019-11-21 22:04:42 +00:00
|
|
|
fprintf(fp, "%s/\n", pattern);
|
2020-01-31 20:16:10 +00:00
|
|
|
free(pattern);
|
2019-11-21 22:04:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int write_patterns_and_update(struct pattern_list *pl)
|
|
|
|
{
|
|
|
|
char *sparse_filename;
|
|
|
|
FILE *fp;
|
2019-11-21 22:04:48 +00:00
|
|
|
int fd;
|
|
|
|
struct lock_file lk = LOCK_INIT;
|
2019-11-21 22:04:46 +00:00
|
|
|
int result;
|
|
|
|
|
2019-11-21 22:04:48 +00:00
|
|
|
sparse_filename = get_sparse_checkout_filename();
|
2020-01-24 21:19:33 +00:00
|
|
|
|
|
|
|
if (safe_create_leading_directories(sparse_filename))
|
|
|
|
die(_("failed to create directory for sparse-checkout file"));
|
|
|
|
|
2019-11-21 22:04:48 +00:00
|
|
|
fd = hold_lock_file_for_update(&lk, sparse_filename,
|
|
|
|
LOCK_DIE_ON_ERROR);
|
2019-11-21 22:04:46 +00:00
|
|
|
|
2019-11-21 22:04:48 +00:00
|
|
|
result = update_working_directory(pl);
|
2019-11-21 22:04:46 +00:00
|
|
|
if (result) {
|
2019-11-21 22:04:48 +00:00
|
|
|
rollback_lock_file(&lk);
|
|
|
|
free(sparse_filename);
|
2019-11-21 22:04:46 +00:00
|
|
|
clear_pattern_list(pl);
|
|
|
|
update_working_directory(NULL);
|
|
|
|
return result;
|
|
|
|
}
|
2019-11-21 22:04:42 +00:00
|
|
|
|
2019-11-21 22:04:48 +00:00
|
|
|
fp = xfdopen(fd, "w");
|
2019-11-21 22:04:42 +00:00
|
|
|
|
|
|
|
if (core_sparse_checkout_cone)
|
|
|
|
write_cone_to_file(fp, pl);
|
|
|
|
else
|
|
|
|
write_patterns_to_file(fp, pl);
|
|
|
|
|
2019-11-21 22:04:48 +00:00
|
|
|
fflush(fp);
|
|
|
|
commit_lock_file(&lk);
|
2019-11-21 22:04:46 +00:00
|
|
|
|
2019-11-21 22:04:42 +00:00
|
|
|
free(sparse_filename);
|
2019-11-21 22:04:46 +00:00
|
|
|
clear_pattern_list(pl);
|
2019-11-21 22:04:42 +00:00
|
|
|
|
2019-11-21 22:04:46 +00:00
|
|
|
return 0;
|
2019-11-21 22:04:42 +00:00
|
|
|
}
|
|
|
|
|
2019-11-21 22:04:34 +00:00
|
|
|
enum sparse_checkout_mode {
|
|
|
|
MODE_NO_PATTERNS = 0,
|
|
|
|
MODE_ALL_PATTERNS = 1,
|
2019-11-21 22:04:42 +00:00
|
|
|
MODE_CONE_PATTERNS = 2,
|
2019-11-21 22:04:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int set_config(enum sparse_checkout_mode mode)
|
|
|
|
{
|
|
|
|
const char *config_path;
|
|
|
|
|
2020-06-05 09:10:03 +00:00
|
|
|
if (upgrade_repository_format(1) < 0)
|
|
|
|
die(_("unable to upgrade repository format to enable worktreeConfig"));
|
2019-11-21 22:04:34 +00:00
|
|
|
if (git_config_set_gently("extensions.worktreeConfig", "true")) {
|
|
|
|
error(_("failed to set extensions.worktreeConfig setting"));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
config_path = git_path("config.worktree");
|
|
|
|
git_config_set_in_file_gently(config_path,
|
|
|
|
"core.sparseCheckout",
|
|
|
|
mode ? "true" : NULL);
|
|
|
|
|
2019-11-21 22:04:42 +00:00
|
|
|
git_config_set_in_file_gently(config_path,
|
|
|
|
"core.sparseCheckoutCone",
|
|
|
|
mode == MODE_CONE_PATTERNS ? "true" : NULL);
|
|
|
|
|
2019-11-21 22:04:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-11-21 22:04:42 +00:00
|
|
|
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;
|
|
|
|
|
2019-11-21 22:04:34 +00:00
|
|
|
static int sparse_checkout_init(int argc, const char **argv)
|
|
|
|
{
|
|
|
|
struct pattern_list pl;
|
|
|
|
char *sparse_filename;
|
|
|
|
int res;
|
2019-11-21 22:04:35 +00:00
|
|
|
struct object_id oid;
|
2019-11-21 22:04:42 +00:00
|
|
|
int mode;
|
2019-11-21 22:04:50 +00:00
|
|
|
struct strbuf pattern = STRBUF_INIT;
|
2019-11-21 22:04:34 +00:00
|
|
|
|
2019-11-21 22:04:42 +00:00
|
|
|
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(),
|
|
|
|
};
|
|
|
|
|
2019-11-21 22:04:51 +00:00
|
|
|
repo_read_index(the_repository);
|
|
|
|
|
2019-11-21 22:04:42 +00:00
|
|
|
argc = parse_options(argc, argv, NULL,
|
|
|
|
builtin_sparse_checkout_init_options,
|
|
|
|
builtin_sparse_checkout_init_usage, 0);
|
|
|
|
|
2019-11-21 22:04:46 +00:00
|
|
|
if (init_opts.cone_mode) {
|
|
|
|
mode = MODE_CONE_PATTERNS;
|
|
|
|
core_sparse_checkout_cone = 1;
|
|
|
|
} else
|
|
|
|
mode = MODE_ALL_PATTERNS;
|
2019-11-21 22:04:42 +00:00
|
|
|
|
|
|
|
if (set_config(mode))
|
2019-11-21 22:04:34 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
memset(&pl, 0, sizeof(pl));
|
|
|
|
|
|
|
|
sparse_filename = get_sparse_checkout_filename();
|
|
|
|
res = add_patterns_from_file_to_list(sparse_filename, "", 0, &pl, NULL);
|
|
|
|
|
|
|
|
/* If we already have a sparse-checkout file, use it. */
|
|
|
|
if (res >= 0) {
|
|
|
|
free(sparse_filename);
|
2019-11-21 22:04:50 +00:00
|
|
|
core_apply_sparse_checkout = 1;
|
|
|
|
return update_working_directory(NULL);
|
2019-11-21 22:04:34 +00:00
|
|
|
}
|
|
|
|
|
2019-11-21 22:04:50 +00:00
|
|
|
if (get_oid("HEAD", &oid)) {
|
|
|
|
FILE *fp;
|
2019-11-21 22:04:34 +00:00
|
|
|
|
2019-11-21 22:04:50 +00:00
|
|
|
/* assume we are in a fresh repo, but update the sparse-checkout file */
|
|
|
|
fp = xfopen(sparse_filename, "w");
|
|
|
|
if (!fp)
|
|
|
|
die(_("failed to open '%s'"), sparse_filename);
|
2019-11-21 22:04:34 +00:00
|
|
|
|
2019-11-21 22:04:50 +00:00
|
|
|
free(sparse_filename);
|
|
|
|
fprintf(fp, "/*\n!/*/\n");
|
|
|
|
fclose(fp);
|
2019-11-21 22:04:35 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-11-21 22:04:50 +00:00
|
|
|
strbuf_addstr(&pattern, "/*");
|
|
|
|
add_pattern(strbuf_detach(&pattern, NULL), empty_base, 0, &pl, 0);
|
|
|
|
strbuf_addstr(&pattern, "!/*/");
|
|
|
|
add_pattern(strbuf_detach(&pattern, NULL), empty_base, 0, &pl, 0);
|
|
|
|
|
|
|
|
return write_patterns_and_update(&pl);
|
2019-11-21 22:04:34 +00:00
|
|
|
}
|
|
|
|
|
2019-11-21 22:04:42 +00:00
|
|
|
static void insert_recursive_pattern(struct pattern_list *pl, struct strbuf *path)
|
2019-11-21 22:04:36 +00:00
|
|
|
{
|
2019-11-21 22:04:42 +00:00
|
|
|
struct pattern_entry *e = xmalloc(sizeof(*e));
|
|
|
|
e->patternlen = path->len;
|
|
|
|
e->pattern = strbuf_detach(path, NULL);
|
sparse-checkout: respect core.ignoreCase in cone mode
When a user uses the sparse-checkout feature in cone mode, they
add patterns using "git sparse-checkout set <dir1> <dir2> ..."
or by using "--stdin" to provide the directories line-by-line over
stdin. This behaviour naturally looks a lot like the way a user
would type "git add <dir1> <dir2> ..."
If core.ignoreCase is enabled, then "git add" will match the input
using a case-insensitive match. Do the same for the sparse-checkout
feature.
Perform case-insensitive checks while updating the skip-worktree
bits during unpack_trees(). This is done by changing the hash
algorithm and hashmap comparison methods to optionally use case-
insensitive methods.
When this is enabled, there is a small performance cost in the
hashing algorithm. To tease out the worst possible case, the
following was run on a repo with a deep directory structure:
git ls-tree -d -r --name-only HEAD |
git sparse-checkout set --stdin
The 'set' command was timed with core.ignoreCase disabled or
enabled. For the repo with a deep history, the numbers were
core.ignoreCase=false: 62s
core.ignoreCase=true: 74s (+19.3%)
For reproducibility, the equivalent test on the Linux kernel
repository had these numbers:
core.ignoreCase=false: 3.1s
core.ignoreCase=true: 3.6s (+16%)
Now, this is not an entirely fair comparison, as most users
will define their sparse cone using more shallow directories,
and the performance improvement from eb42feca97 ("unpack-trees:
hash less in cone mode" 2019-11-21) can remove most of the
hash cost. For a more realistic test, drop the "-r" from the
ls-tree command to store only the first-level directories.
In that case, the Linux kernel repository takes 0.2-0.25s in
each case, and the deep repository takes one second, plus or
minus 0.05s, in each case.
Thus, we _can_ demonstrate a cost to this change, but it is
unlikely to matter to any reasonable sparse-checkout cone.
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-12-13 18:09:53 +00:00
|
|
|
hashmap_entry_init(&e->ent,
|
|
|
|
ignore_case ?
|
|
|
|
strihash(e->pattern) :
|
|
|
|
strhash(e->pattern));
|
2019-11-21 22:04:36 +00:00
|
|
|
|
2019-11-21 22:04:42 +00:00
|
|
|
hashmap_add(&pl->recursive_hashmap, &e->ent);
|
2019-11-21 22:04:36 +00:00
|
|
|
|
2019-11-21 22:04:42 +00:00
|
|
|
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);
|
sparse-checkout: respect core.ignoreCase in cone mode
When a user uses the sparse-checkout feature in cone mode, they
add patterns using "git sparse-checkout set <dir1> <dir2> ..."
or by using "--stdin" to provide the directories line-by-line over
stdin. This behaviour naturally looks a lot like the way a user
would type "git add <dir1> <dir2> ..."
If core.ignoreCase is enabled, then "git add" will match the input
using a case-insensitive match. Do the same for the sparse-checkout
feature.
Perform case-insensitive checks while updating the skip-worktree
bits during unpack_trees(). This is done by changing the hash
algorithm and hashmap comparison methods to optionally use case-
insensitive methods.
When this is enabled, there is a small performance cost in the
hashing algorithm. To tease out the worst possible case, the
following was run on a repo with a deep directory structure:
git ls-tree -d -r --name-only HEAD |
git sparse-checkout set --stdin
The 'set' command was timed with core.ignoreCase disabled or
enabled. For the repo with a deep history, the numbers were
core.ignoreCase=false: 62s
core.ignoreCase=true: 74s (+19.3%)
For reproducibility, the equivalent test on the Linux kernel
repository had these numbers:
core.ignoreCase=false: 3.1s
core.ignoreCase=true: 3.6s (+16%)
Now, this is not an entirely fair comparison, as most users
will define their sparse cone using more shallow directories,
and the performance improvement from eb42feca97 ("unpack-trees:
hash less in cone mode" 2019-11-21) can remove most of the
hash cost. For a more realistic test, drop the "-r" from the
ls-tree command to store only the first-level directories.
In that case, the Linux kernel repository takes 0.2-0.25s in
each case, and the deep repository takes one second, plus or
minus 0.05s, in each case.
Thus, we _can_ demonstrate a cost to this change, but it is
unlikely to matter to any reasonable sparse-checkout cone.
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-12-13 18:09:53 +00:00
|
|
|
hashmap_entry_init(&e->ent,
|
|
|
|
ignore_case ?
|
|
|
|
strihash(e->pattern) :
|
|
|
|
strhash(e->pattern));
|
2019-11-21 22:04:42 +00:00
|
|
|
|
|
|
|
if (!hashmap_get_entry(&pl->parent_hashmap, e, ent, NULL))
|
|
|
|
hashmap_add(&pl->parent_hashmap, &e->ent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void strbuf_to_cone_pattern(struct strbuf *line, struct pattern_list *pl)
|
|
|
|
{
|
|
|
|
strbuf_trim(line);
|
|
|
|
|
|
|
|
strbuf_trim_trailing_dir_sep(line);
|
|
|
|
|
2020-02-11 15:02:24 +00:00
|
|
|
if (strbuf_normalize_path(line))
|
|
|
|
die(_("could not normalize path %s"), line->buf);
|
|
|
|
|
2019-11-21 22:04:42 +00:00
|
|
|
if (!line->len)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (line->buf[0] != '/')
|
2020-02-09 13:44:23 +00:00
|
|
|
strbuf_insertstr(line, 0, "/");
|
2019-11-21 22:04:42 +00:00
|
|
|
|
|
|
|
insert_recursive_pattern(pl, line);
|
2019-11-21 22:04:36 +00:00
|
|
|
}
|
|
|
|
|
2019-11-21 22:04:37 +00:00
|
|
|
static char const * const builtin_sparse_checkout_set_usage[] = {
|
2020-02-11 15:02:23 +00:00
|
|
|
N_("git sparse-checkout (set|add) (--stdin | <patterns>)"),
|
2019-11-21 22:04:37 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct sparse_checkout_set_opts {
|
|
|
|
int use_stdin;
|
|
|
|
} set_opts;
|
|
|
|
|
2020-02-11 15:02:21 +00:00
|
|
|
static void add_patterns_from_input(struct pattern_list *pl,
|
|
|
|
int argc, const char **argv)
|
2019-11-21 22:04:36 +00:00
|
|
|
{
|
|
|
|
int i;
|
2019-11-21 22:04:42 +00:00
|
|
|
if (core_sparse_checkout_cone) {
|
2019-11-21 22:04:37 +00:00
|
|
|
struct strbuf line = STRBUF_INIT;
|
|
|
|
|
2020-02-11 15:02:21 +00:00
|
|
|
hashmap_init(&pl->recursive_hashmap, pl_hashmap_cmp, NULL, 0);
|
|
|
|
hashmap_init(&pl->parent_hashmap, pl_hashmap_cmp, NULL, 0);
|
|
|
|
pl->use_cone_patterns = 1;
|
2019-11-21 22:04:42 +00:00
|
|
|
|
|
|
|
if (set_opts.use_stdin) {
|
2020-01-31 20:16:11 +00:00
|
|
|
struct strbuf unquoted = STRBUF_INIT;
|
|
|
|
while (!strbuf_getline(&line, stdin)) {
|
|
|
|
if (line.buf[0] == '"') {
|
|
|
|
strbuf_reset(&unquoted);
|
|
|
|
if (unquote_c_style(&unquoted, line.buf, NULL))
|
|
|
|
die(_("unable to unquote C-style string '%s'"),
|
|
|
|
line.buf);
|
|
|
|
|
|
|
|
strbuf_swap(&unquoted, &line);
|
|
|
|
}
|
|
|
|
|
2020-02-11 15:02:21 +00:00
|
|
|
strbuf_to_cone_pattern(&line, pl);
|
2020-01-31 20:16:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_release(&unquoted);
|
2019-11-21 22:04:42 +00:00
|
|
|
} else {
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
strbuf_setlen(&line, 0);
|
|
|
|
strbuf_addstr(&line, argv[i]);
|
2020-02-11 15:02:21 +00:00
|
|
|
strbuf_to_cone_pattern(&line, pl);
|
2019-11-21 22:04:42 +00:00
|
|
|
}
|
2019-11-21 22:04:37 +00:00
|
|
|
}
|
|
|
|
} else {
|
2019-11-21 22:04:42 +00:00
|
|
|
if (set_opts.use_stdin) {
|
|
|
|
struct strbuf line = STRBUF_INIT;
|
|
|
|
|
|
|
|
while (!strbuf_getline(&line, stdin)) {
|
|
|
|
size_t len;
|
|
|
|
char *buf = strbuf_detach(&line, &len);
|
2020-02-11 15:02:21 +00:00
|
|
|
add_pattern(buf, empty_base, 0, pl, 0);
|
2019-11-21 22:04:42 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (i = 0; i < argc; i++)
|
2020-02-11 15:02:21 +00:00
|
|
|
add_pattern(argv[i], empty_base, 0, pl, 0);
|
2019-11-21 22:04:42 +00:00
|
|
|
}
|
2019-11-21 22:04:37 +00:00
|
|
|
}
|
2020-02-11 15:02:21 +00:00
|
|
|
}
|
|
|
|
|
2020-02-11 15:02:22 +00:00
|
|
|
enum modify_type {
|
|
|
|
REPLACE,
|
2020-02-11 15:02:23 +00:00
|
|
|
ADD,
|
2020-02-11 15:02:22 +00:00
|
|
|
};
|
|
|
|
|
2020-02-11 15:02:23 +00:00
|
|
|
static void add_patterns_cone_mode(int argc, const char **argv,
|
|
|
|
struct pattern_list *pl)
|
|
|
|
{
|
|
|
|
struct strbuf buffer = STRBUF_INIT;
|
|
|
|
struct pattern_entry *pe;
|
|
|
|
struct hashmap_iter iter;
|
|
|
|
struct pattern_list existing;
|
|
|
|
char *sparse_filename = get_sparse_checkout_filename();
|
|
|
|
|
|
|
|
add_patterns_from_input(pl, argc, argv);
|
|
|
|
|
|
|
|
memset(&existing, 0, sizeof(existing));
|
|
|
|
existing.use_cone_patterns = core_sparse_checkout_cone;
|
|
|
|
|
|
|
|
if (add_patterns_from_file_to_list(sparse_filename, "", 0,
|
|
|
|
&existing, NULL))
|
|
|
|
die(_("unable to load existing sparse-checkout patterns"));
|
|
|
|
free(sparse_filename);
|
|
|
|
|
|
|
|
hashmap_for_each_entry(&existing.recursive_hashmap, &iter, pe, ent) {
|
|
|
|
if (!hashmap_contains_parent(&pl->recursive_hashmap,
|
|
|
|
pe->pattern, &buffer) ||
|
|
|
|
!hashmap_contains_parent(&pl->parent_hashmap,
|
|
|
|
pe->pattern, &buffer)) {
|
|
|
|
strbuf_reset(&buffer);
|
|
|
|
strbuf_addstr(&buffer, pe->pattern);
|
|
|
|
insert_recursive_pattern(pl, &buffer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
clear_pattern_list(&existing);
|
|
|
|
strbuf_release(&buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_patterns_literal(int argc, const char **argv,
|
|
|
|
struct pattern_list *pl)
|
|
|
|
{
|
|
|
|
char *sparse_filename = get_sparse_checkout_filename();
|
|
|
|
if (add_patterns_from_file_to_list(sparse_filename, "", 0,
|
|
|
|
pl, NULL))
|
|
|
|
die(_("unable to load existing sparse-checkout patterns"));
|
|
|
|
free(sparse_filename);
|
|
|
|
add_patterns_from_input(pl, argc, argv);
|
|
|
|
}
|
|
|
|
|
2020-02-11 15:02:22 +00:00
|
|
|
static int modify_pattern_list(int argc, const char **argv, enum modify_type m)
|
2020-02-11 15:02:21 +00:00
|
|
|
{
|
|
|
|
int result;
|
|
|
|
int changed_config = 0;
|
2020-02-11 15:02:22 +00:00
|
|
|
struct pattern_list pl;
|
2020-02-11 15:02:21 +00:00
|
|
|
memset(&pl, 0, sizeof(pl));
|
|
|
|
|
2020-02-11 15:02:23 +00:00
|
|
|
switch (m) {
|
|
|
|
case ADD:
|
|
|
|
if (core_sparse_checkout_cone)
|
|
|
|
add_patterns_cone_mode(argc, argv, &pl);
|
|
|
|
else
|
|
|
|
add_patterns_literal(argc, argv, &pl);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case REPLACE:
|
|
|
|
add_patterns_from_input(&pl, argc, argv);
|
|
|
|
break;
|
|
|
|
}
|
2019-11-21 22:04:36 +00:00
|
|
|
|
|
|
|
if (!core_apply_sparse_checkout) {
|
|
|
|
set_config(MODE_ALL_PATTERNS);
|
|
|
|
core_apply_sparse_checkout = 1;
|
|
|
|
changed_config = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
result = write_patterns_and_update(&pl);
|
|
|
|
|
|
|
|
if (result && changed_config)
|
|
|
|
set_config(MODE_NO_PATTERNS);
|
|
|
|
|
|
|
|
clear_pattern_list(&pl);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2020-02-11 15:02:23 +00:00
|
|
|
static int sparse_checkout_set(int argc, const char **argv, const char *prefix,
|
|
|
|
enum modify_type m)
|
2020-02-11 15:02:22 +00:00
|
|
|
{
|
|
|
|
static struct option builtin_sparse_checkout_set_options[] = {
|
|
|
|
OPT_BOOL(0, "stdin", &set_opts.use_stdin,
|
|
|
|
N_("read patterns from standard in")),
|
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
|
|
|
|
repo_read_index(the_repository);
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix,
|
|
|
|
builtin_sparse_checkout_set_options,
|
|
|
|
builtin_sparse_checkout_set_usage,
|
|
|
|
PARSE_OPT_KEEP_UNKNOWN);
|
|
|
|
|
2020-02-11 15:02:23 +00:00
|
|
|
return modify_pattern_list(argc, argv, m);
|
2020-02-11 15:02:22 +00:00
|
|
|
}
|
|
|
|
|
2020-09-30 12:30:10 +00:00
|
|
|
static char const * const builtin_sparse_checkout_reapply_usage[] = {
|
|
|
|
N_("git sparse-checkout reapply"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2020-03-27 00:49:01 +00:00
|
|
|
static int sparse_checkout_reapply(int argc, const char **argv)
|
|
|
|
{
|
2020-09-30 12:30:10 +00:00
|
|
|
static struct option builtin_sparse_checkout_reapply_options[] = {
|
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, NULL,
|
|
|
|
builtin_sparse_checkout_reapply_options,
|
|
|
|
builtin_sparse_checkout_reapply_usage, 0);
|
|
|
|
|
2020-03-27 00:49:01 +00:00
|
|
|
repo_read_index(the_repository);
|
|
|
|
return update_working_directory(NULL);
|
|
|
|
}
|
|
|
|
|
2020-09-30 12:30:10 +00:00
|
|
|
static char const * const builtin_sparse_checkout_disable_usage[] = {
|
|
|
|
N_("git sparse-checkout disable"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2019-11-21 22:04:38 +00:00
|
|
|
static int sparse_checkout_disable(int argc, const char **argv)
|
|
|
|
{
|
2020-09-30 12:30:10 +00:00
|
|
|
static struct option builtin_sparse_checkout_disable_options[] = {
|
|
|
|
OPT_END(),
|
|
|
|
};
|
2019-11-21 22:04:47 +00:00
|
|
|
struct pattern_list pl;
|
|
|
|
struct strbuf match_all = STRBUF_INIT;
|
2019-11-21 22:04:38 +00:00
|
|
|
|
2020-09-30 12:30:10 +00:00
|
|
|
argc = parse_options(argc, argv, NULL,
|
|
|
|
builtin_sparse_checkout_disable_options,
|
|
|
|
builtin_sparse_checkout_disable_usage, 0);
|
|
|
|
|
2019-11-21 22:04:51 +00:00
|
|
|
repo_read_index(the_repository);
|
|
|
|
|
2019-11-21 22:04:47 +00:00
|
|
|
memset(&pl, 0, sizeof(pl));
|
|
|
|
hashmap_init(&pl.recursive_hashmap, pl_hashmap_cmp, NULL, 0);
|
|
|
|
hashmap_init(&pl.parent_hashmap, pl_hashmap_cmp, NULL, 0);
|
|
|
|
pl.use_cone_patterns = 0;
|
|
|
|
core_apply_sparse_checkout = 1;
|
2019-11-21 22:04:38 +00:00
|
|
|
|
2019-11-21 22:04:47 +00:00
|
|
|
strbuf_addstr(&match_all, "/*");
|
|
|
|
add_pattern(strbuf_detach(&match_all, NULL), empty_base, 0, &pl, 0);
|
2019-11-21 22:04:38 +00:00
|
|
|
|
2019-11-21 22:04:47 +00:00
|
|
|
if (update_working_directory(&pl))
|
2019-11-21 22:04:38 +00:00
|
|
|
die(_("error while refreshing working directory"));
|
|
|
|
|
2019-11-21 22:04:47 +00:00
|
|
|
clear_pattern_list(&pl);
|
2019-11-21 22:04:38 +00:00
|
|
|
return set_config(MODE_NO_PATTERNS);
|
|
|
|
}
|
|
|
|
|
2019-11-21 22:04:33 +00:00
|
|
|
int cmd_sparse_checkout(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
static struct option builtin_sparse_checkout_options[] = {
|
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
|
|
|
|
if (argc == 2 && !strcmp(argv[1], "-h"))
|
|
|
|
usage_with_options(builtin_sparse_checkout_usage,
|
|
|
|
builtin_sparse_checkout_options);
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix,
|
|
|
|
builtin_sparse_checkout_options,
|
|
|
|
builtin_sparse_checkout_usage,
|
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
|
|
|
|
git_config(git_default_config, NULL);
|
|
|
|
|
|
|
|
if (argc > 0) {
|
|
|
|
if (!strcmp(argv[0], "list"))
|
|
|
|
return sparse_checkout_list(argc, argv);
|
2019-11-21 22:04:34 +00:00
|
|
|
if (!strcmp(argv[0], "init"))
|
|
|
|
return sparse_checkout_init(argc, argv);
|
2019-11-21 22:04:36 +00:00
|
|
|
if (!strcmp(argv[0], "set"))
|
2020-02-11 15:02:23 +00:00
|
|
|
return sparse_checkout_set(argc, argv, prefix, REPLACE);
|
|
|
|
if (!strcmp(argv[0], "add"))
|
|
|
|
return sparse_checkout_set(argc, argv, prefix, ADD);
|
2020-03-27 00:49:01 +00:00
|
|
|
if (!strcmp(argv[0], "reapply"))
|
|
|
|
return sparse_checkout_reapply(argc, argv);
|
2019-11-21 22:04:38 +00:00
|
|
|
if (!strcmp(argv[0], "disable"))
|
|
|
|
return sparse_checkout_disable(argc, argv);
|
2019-11-21 22:04:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
usage_with_options(builtin_sparse_checkout_usage,
|
|
|
|
builtin_sparse_checkout_options);
|
|
|
|
}
|