mirror of
https://github.com/git/git.git
synced 2024-05-12 05:56:09 +02:00
Merge branch 'vd/sparse-reset'
Various operating modes of "git reset" have been made to work better with the sparse index. * vd/sparse-reset: unpack-trees: improve performance of next_cache_entry reset: make --mixed sparse-aware reset: make sparse-aware (except --mixed) reset: integrate with sparse index reset: expand test coverage for sparse checkouts sparse-index: update command for expand/collapse test reset: preserve skip-worktree bit in mixed reset reset: rename is_missing to !is_in_reset_tree
This commit is contained in:
Junio C Hamano
commit
f0850875fd
113
builtin/reset.c
113
builtin/reset.c
|
|
@ -25,6 +25,7 @@
|
|||
#include "cache-tree.h"
|
||||
#include "submodule.h"
|
||||
#include "submodule-config.h"
|
||||
#include "dir.h"
|
||||
|
||||
#define REFRESH_INDEX_DELAY_WARNING_IN_MS (2 * 1000)
|
||||
|
||||
|
|
@ -136,21 +137,36 @@ static void update_index_from_diff(struct diff_queue_struct *q,
|
|||
int intent_to_add = *(int *)data;
|
||||
|
||||
for (i = 0; i < q->nr; i++) {
|
||||
int pos;
|
||||
struct diff_filespec *one = q->queue[i]->one;
|
||||
int is_missing = !(one->mode && !is_null_oid(&one->oid));
|
||||
int is_in_reset_tree = one->mode && !is_null_oid(&one->oid);
|
||||
struct cache_entry *ce;
|
||||
|
||||
if (is_missing && !intent_to_add) {
|
||||
if (!is_in_reset_tree && !intent_to_add) {
|
||||
remove_file_from_cache(one->path);
|
||||
continue;
|
||||
}
|
||||
|
||||
ce = make_cache_entry(&the_index, one->mode, &one->oid, one->path,
|
||||
0, 0);
|
||||
|
||||
/*
|
||||
* If the file 1) corresponds to an existing index entry with
|
||||
* skip-worktree set, or 2) does not exist in the index but is
|
||||
* outside the sparse checkout definition, add a skip-worktree bit
|
||||
* to the new index entry. Note that a sparse index will be expanded
|
||||
* if this entry is outside the sparse cone - this is necessary
|
||||
* to properly construct the reset sparse directory.
|
||||
*/
|
||||
pos = cache_name_pos(one->path, strlen(one->path));
|
||||
if ((pos >= 0 && ce_skip_worktree(active_cache[pos])) ||
|
||||
(pos < 0 && !path_in_sparse_checkout(one->path, &the_index)))
|
||||
ce->ce_flags |= CE_SKIP_WORKTREE;
|
||||
|
||||
if (!ce)
|
||||
die(_("make_cache_entry failed for path '%s'"),
|
||||
one->path);
|
||||
if (is_missing) {
|
||||
if (!is_in_reset_tree) {
|
||||
ce->ce_flags |= CE_INTENT_TO_ADD;
|
||||
set_object_name_for_intent_to_add_entry(ce);
|
||||
}
|
||||
|
|
@ -158,6 +174,82 @@ static void update_index_from_diff(struct diff_queue_struct *q,
|
|||
}
|
||||
}
|
||||
|
||||
static int pathspec_needs_expanded_index(const struct pathspec *pathspec)
|
||||
{
|
||||
unsigned int i, pos;
|
||||
int res = 0;
|
||||
char *skip_worktree_seen = NULL;
|
||||
|
||||
/*
|
||||
* When using a magic pathspec, assume for the sake of simplicity that
|
||||
* the index needs to be expanded to match all matchable files.
|
||||
*/
|
||||
if (pathspec->magic)
|
||||
return 1;
|
||||
|
||||
for (i = 0; i < pathspec->nr; i++) {
|
||||
struct pathspec_item item = pathspec->items[i];
|
||||
|
||||
/*
|
||||
* If the pathspec item has a wildcard, the index should be expanded
|
||||
* if the pathspec has the possibility of matching a subset of entries inside
|
||||
* of a sparse directory (but not the entire directory).
|
||||
*
|
||||
* If the pathspec item is a literal path, the index only needs to be expanded
|
||||
* if a) the pathspec isn't in the sparse checkout cone (to make sure we don't
|
||||
* expand for in-cone files) and b) it doesn't match any sparse directories
|
||||
* (since we can reset whole sparse directories without expanding them).
|
||||
*/
|
||||
if (item.nowildcard_len < item.len) {
|
||||
/*
|
||||
* Special case: if the pattern is a path inside the cone
|
||||
* followed by only wildcards, the pattern cannot match
|
||||
* partial sparse directories, so we don't expand the index.
|
||||
*/
|
||||
if (path_in_cone_mode_sparse_checkout(item.original, &the_index) &&
|
||||
strspn(item.original + item.nowildcard_len, "*") == item.len - item.nowildcard_len)
|
||||
continue;
|
||||
|
||||
for (pos = 0; pos < active_nr; pos++) {
|
||||
struct cache_entry *ce = active_cache[pos];
|
||||
|
||||
if (!S_ISSPARSEDIR(ce->ce_mode))
|
||||
continue;
|
||||
|
||||
/*
|
||||
* If the pre-wildcard length is longer than the sparse
|
||||
* directory name and the sparse directory is the first
|
||||
* component of the pathspec, need to expand the index.
|
||||
*/
|
||||
if (item.nowildcard_len > ce_namelen(ce) &&
|
||||
!strncmp(item.original, ce->name, ce_namelen(ce))) {
|
||||
res = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* If the pre-wildcard length is shorter than the sparse
|
||||
* directory and the pathspec does not match the whole
|
||||
* directory, need to expand the index.
|
||||
*/
|
||||
if (!strncmp(item.original, ce->name, item.nowildcard_len) &&
|
||||
wildmatch(item.original, ce->name, 0)) {
|
||||
res = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else if (!path_in_cone_mode_sparse_checkout(item.original, &the_index) &&
|
||||
!matches_skip_worktree(pathspec, i, &skip_worktree_seen))
|
||||
res = 1;
|
||||
|
||||
if (res > 0)
|
||||
break;
|
||||
}
|
||||
|
||||
free(skip_worktree_seen);
|
||||
return res;
|
||||
}
|
||||
|
||||
static int read_from_tree(const struct pathspec *pathspec,
|
||||
struct object_id *tree_oid,
|
||||
int intent_to_add)
|
||||
|
|
@ -170,7 +262,13 @@ static int read_from_tree(const struct pathspec *pathspec,
|
|||
opt.format_callback = update_index_from_diff;
|
||||
opt.format_callback_data = &intent_to_add;
|
||||
opt.flags.override_submodule_config = 1;
|
||||
opt.flags.recursive = 1;
|
||||
opt.repo = the_repository;
|
||||
opt.change = diff_change;
|
||||
opt.add_remove = diff_addremove;
|
||||
|
||||
if (pathspec->nr && the_index.sparse_index && pathspec_needs_expanded_index(pathspec))
|
||||
ensure_full_index(&the_index);
|
||||
|
||||
if (do_diff_cache(tree_oid, &opt))
|
||||
return 1;
|
||||
|
|
@ -249,9 +347,6 @@ static void parse_args(struct pathspec *pathspec,
|
|||
}
|
||||
*rev_ret = rev;
|
||||
|
||||
if (read_cache() < 0)
|
||||
die(_("index file corrupt"));
|
||||
|
||||
parse_pathspec(pathspec, 0,
|
||||
PATHSPEC_PREFER_FULL |
|
||||
(patch_mode ? PATHSPEC_PREFIX_ORIGIN : 0),
|
||||
|
|
@ -397,6 +492,12 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
|
|||
if (intent_to_add && reset_type != MIXED)
|
||||
die(_("-N can only be used with --mixed"));
|
||||
|
||||
prepare_repo_settings(the_repository);
|
||||
the_repository->settings.command_requires_full_index = 0;
|
||||
|
||||
if (read_cache() < 0)
|
||||
die(_("index file corrupt"));
|
||||
|
||||
/* Soft reset does not touch the index file nor the working tree
|
||||
* at all, but requires them in a good order. Other resets reset
|
||||
* the index file to the tree object we are switching to. */
|
||||
|
|
|
|||
46
cache-tree.c
46
cache-tree.c
|
|
@ -741,15 +741,26 @@ int write_index_as_tree(struct object_id *oid, struct index_state *index_state,
|
|||
return ret;
|
||||
}
|
||||
|
||||
static void prime_cache_tree_sparse_dir(struct cache_tree *it,
|
||||
struct tree *tree)
|
||||
{
|
||||
|
||||
oidcpy(&it->oid, &tree->object.oid);
|
||||
it->entry_count = 1;
|
||||
}
|
||||
|
||||
static void prime_cache_tree_rec(struct repository *r,
|
||||
struct cache_tree *it,
|
||||
struct tree *tree)
|
||||
struct tree *tree,
|
||||
struct strbuf *tree_path)
|
||||
{
|
||||
struct tree_desc desc;
|
||||
struct name_entry entry;
|
||||
int cnt;
|
||||
int base_path_len = tree_path->len;
|
||||
|
||||
oidcpy(&it->oid, &tree->object.oid);
|
||||
|
||||
init_tree_desc(&desc, tree->buffer, tree->size);
|
||||
cnt = 0;
|
||||
while (tree_entry(&desc, &entry)) {
|
||||
|
|
@ -758,14 +769,40 @@ static void prime_cache_tree_rec(struct repository *r,
|
|||
else {
|
||||
struct cache_tree_sub *sub;
|
||||
struct tree *subtree = lookup_tree(r, &entry.oid);
|
||||
|
||||
if (!subtree->object.parsed)
|
||||
parse_tree(subtree);
|
||||
sub = cache_tree_sub(it, entry.path);
|
||||
sub->cache_tree = cache_tree();
|
||||
prime_cache_tree_rec(r, sub->cache_tree, subtree);
|
||||
|
||||
/*
|
||||
* Recursively-constructed subtree path is only needed when working
|
||||
* in a sparse index (where it's used to determine whether the
|
||||
* subtree is a sparse directory in the index).
|
||||
*/
|
||||
if (r->index->sparse_index) {
|
||||
strbuf_setlen(tree_path, base_path_len);
|
||||
strbuf_grow(tree_path, base_path_len + entry.pathlen + 1);
|
||||
strbuf_add(tree_path, entry.path, entry.pathlen);
|
||||
strbuf_addch(tree_path, '/');
|
||||
}
|
||||
|
||||
/*
|
||||
* If a sparse index is in use, the directory being processed may be
|
||||
* sparse. To confirm that, we can check whether an entry with that
|
||||
* exact name exists in the index. If it does, the created subtree
|
||||
* should be sparse. Otherwise, cache tree expansion should continue
|
||||
* as normal.
|
||||
*/
|
||||
if (r->index->sparse_index &&
|
||||
index_entry_exists(r->index, tree_path->buf, tree_path->len))
|
||||
prime_cache_tree_sparse_dir(sub->cache_tree, subtree);
|
||||
else
|
||||
prime_cache_tree_rec(r, sub->cache_tree, subtree, tree_path);
|
||||
cnt += sub->cache_tree->entry_count;
|
||||
}
|
||||
}
|
||||
|
||||
it->entry_count = cnt;
|
||||
}
|
||||
|
||||
|
|
@ -773,11 +810,14 @@ void prime_cache_tree(struct repository *r,
|
|||
struct index_state *istate,
|
||||
struct tree *tree)
|
||||
{
|
||||
struct strbuf tree_path = STRBUF_INIT;
|
||||
|
||||
trace2_region_enter("cache-tree", "prime_cache_tree", the_repository);
|
||||
cache_tree_free(&istate->cache_tree);
|
||||
istate->cache_tree = cache_tree();
|
||||
|
||||
prime_cache_tree_rec(r, istate->cache_tree, tree);
|
||||
prime_cache_tree_rec(r, istate->cache_tree, tree, &tree_path);
|
||||
strbuf_release(&tree_path);
|
||||
istate->cache_changed |= CACHE_TREE_CHANGED;
|
||||
trace2_region_leave("cache-tree", "prime_cache_tree", the_repository);
|
||||
}
|
||||
|
|
|
|||
10
cache.h
10
cache.h
|
|
@ -816,6 +816,16 @@ struct cache_entry *index_file_exists(struct index_state *istate, const char *na
|
|||
*/
|
||||
int index_name_pos(struct index_state *, const char *name, int namelen);
|
||||
|
||||
/*
|
||||
* Determines whether an entry with the given name exists within the
|
||||
* given index. The return value is 1 if an exact match is found, otherwise
|
||||
* it is 0. Note that, unlike index_name_pos, this function does not expand
|
||||
* the index if it is sparse. If an item exists within the full index but it
|
||||
* is contained within a sparse directory (and not in the sparse index), 0 is
|
||||
* returned.
|
||||
*/
|
||||
int index_entry_exists(struct index_state *, const char *name, int namelen);
|
||||
|
||||
/*
|
||||
* Some functions return the negative complement of an insert position when a
|
||||
* precise match was not found but a position was found where the entry would
|
||||
|
|
|
|||
27
read-cache.c
27
read-cache.c
|
|
@ -68,6 +68,11 @@
|
|||
*/
|
||||
#define CACHE_ENTRY_PATH_LENGTH 80
|
||||
|
||||
enum index_search_mode {
|
||||
NO_EXPAND_SPARSE = 0,
|
||||
EXPAND_SPARSE = 1
|
||||
};
|
||||
|
||||
static inline struct cache_entry *mem_pool__ce_alloc(struct mem_pool *mem_pool, size_t len)
|
||||
{
|
||||
struct cache_entry *ce;
|
||||
|
|
@ -551,7 +556,10 @@ int cache_name_stage_compare(const char *name1, int len1, int stage1, const char
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int index_name_stage_pos(struct index_state *istate, const char *name, int namelen, int stage)
|
||||
static int index_name_stage_pos(struct index_state *istate,
|
||||
const char *name, int namelen,
|
||||
int stage,
|
||||
enum index_search_mode search_mode)
|
||||
{
|
||||
int first, last;
|
||||
|
||||
|
|
@ -570,7 +578,7 @@ static int index_name_stage_pos(struct index_state *istate, const char *name, in
|
|||
first = next+1;
|
||||
}
|
||||
|
||||
if (istate->sparse_index &&
|
||||
if (search_mode == EXPAND_SPARSE && istate->sparse_index &&
|
||||
first > 0) {
|
||||
/* Note: first <= istate->cache_nr */
|
||||
struct cache_entry *ce = istate->cache[first - 1];
|
||||
|
|
@ -586,7 +594,7 @@ static int index_name_stage_pos(struct index_state *istate, const char *name, in
|
|||
ce_namelen(ce) < namelen &&
|
||||
!strncmp(name, ce->name, ce_namelen(ce))) {
|
||||
ensure_full_index(istate);
|
||||
return index_name_stage_pos(istate, name, namelen, stage);
|
||||
return index_name_stage_pos(istate, name, namelen, stage, search_mode);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -595,7 +603,12 @@ static int index_name_stage_pos(struct index_state *istate, const char *name, in
|
|||
|
||||
int index_name_pos(struct index_state *istate, const char *name, int namelen)
|
||||
{
|
||||
return index_name_stage_pos(istate, name, namelen, 0);
|
||||
return index_name_stage_pos(istate, name, namelen, 0, EXPAND_SPARSE);
|
||||
}
|
||||
|
||||
int index_entry_exists(struct index_state *istate, const char *name, int namelen)
|
||||
{
|
||||
return index_name_stage_pos(istate, name, namelen, 0, NO_EXPAND_SPARSE) >= 0;
|
||||
}
|
||||
|
||||
int remove_index_entry_at(struct index_state *istate, int pos)
|
||||
|
|
@ -1237,7 +1250,7 @@ static int has_dir_name(struct index_state *istate,
|
|||
*/
|
||||
}
|
||||
|
||||
pos = index_name_stage_pos(istate, name, len, stage);
|
||||
pos = index_name_stage_pos(istate, name, len, stage, EXPAND_SPARSE);
|
||||
if (pos >= 0) {
|
||||
/*
|
||||
* Found one, but not so fast. This could
|
||||
|
|
@ -1337,7 +1350,7 @@ static int add_index_entry_with_check(struct index_state *istate, struct cache_e
|
|||
strcmp(ce->name, istate->cache[istate->cache_nr - 1]->name) > 0)
|
||||
pos = index_pos_to_insert_pos(istate->cache_nr);
|
||||
else
|
||||
pos = index_name_stage_pos(istate, ce->name, ce_namelen(ce), ce_stage(ce));
|
||||
pos = index_name_stage_pos(istate, ce->name, ce_namelen(ce), ce_stage(ce), EXPAND_SPARSE);
|
||||
|
||||
/* existing match? Just replace it. */
|
||||
if (pos >= 0) {
|
||||
|
|
@ -1372,7 +1385,7 @@ static int add_index_entry_with_check(struct index_state *istate, struct cache_e
|
|||
if (!ok_to_replace)
|
||||
return error(_("'%s' appears as both a file and as a directory"),
|
||||
ce->name);
|
||||
pos = index_name_stage_pos(istate, ce->name, ce_namelen(ce), ce_stage(ce));
|
||||
pos = index_name_stage_pos(istate, ce->name, ce_namelen(ce), ce_stage(ce), EXPAND_SPARSE);
|
||||
pos = -pos-1;
|
||||
}
|
||||
return pos + 1;
|
||||
|
|
|
|||
|
|
@ -110,5 +110,8 @@ test_perf_on_all git add -A
|
|||
test_perf_on_all git add .
|
||||
test_perf_on_all git commit -a -m A
|
||||
test_perf_on_all git checkout -f -
|
||||
test_perf_on_all git reset
|
||||
test_perf_on_all git reset --hard
|
||||
test_perf_on_all git reset -- does-not-exist
|
||||
|
||||
test_done
|
||||
|
|
|
|||
|
|
@ -489,26 +489,118 @@ test_expect_failure 'blame with pathspec outside sparse definition' '
|
|||
test_all_match git blame deep/deeper2/deepest/a
|
||||
'
|
||||
|
||||
# NEEDSWORK: a sparse-checkout behaves differently from a full checkout
|
||||
# in this scenario, but it shouldn't.
|
||||
test_expect_failure 'checkout and reset (mixed)' '
|
||||
test_expect_success 'checkout and reset (mixed)' '
|
||||
init_repos &&
|
||||
|
||||
test_all_match git checkout -b reset-test update-deep &&
|
||||
test_all_match git reset deepest &&
|
||||
test_all_match git reset update-folder1 &&
|
||||
test_all_match git reset update-folder2
|
||||
|
||||
# Because skip-worktree is preserved, resetting to update-folder1
|
||||
# will show worktree changes for folder1/a in full-checkout, but not
|
||||
# in sparse-checkout or sparse-index.
|
||||
git -C full-checkout reset update-folder1 >full-checkout-out &&
|
||||
test_sparse_match git reset update-folder1 &&
|
||||
grep "M folder1/a" full-checkout-out &&
|
||||
! grep "M folder1/a" sparse-checkout-out &&
|
||||
run_on_sparse test_path_is_missing folder1
|
||||
'
|
||||
|
||||
# NEEDSWORK: a sparse-checkout behaves differently from a full checkout
|
||||
# in this scenario, but it shouldn't.
|
||||
test_expect_success 'checkout and reset (mixed) [sparse]' '
|
||||
test_expect_success 'checkout and reset (merge)' '
|
||||
init_repos &&
|
||||
|
||||
test_sparse_match git checkout -b reset-test update-deep &&
|
||||
test_sparse_match git reset deepest &&
|
||||
test_sparse_match git reset update-folder1 &&
|
||||
test_sparse_match git reset update-folder2
|
||||
write_script edit-contents <<-\EOF &&
|
||||
echo text >>$1
|
||||
EOF
|
||||
|
||||
test_all_match git checkout -b reset-test update-deep &&
|
||||
run_on_all ../edit-contents a &&
|
||||
test_all_match git reset --merge deepest &&
|
||||
test_all_match git status --porcelain=v2 &&
|
||||
|
||||
test_all_match git reset --hard update-deep &&
|
||||
run_on_all ../edit-contents deep/a &&
|
||||
test_all_match test_must_fail git reset --merge deepest
|
||||
'
|
||||
|
||||
test_expect_success 'checkout and reset (keep)' '
|
||||
init_repos &&
|
||||
|
||||
write_script edit-contents <<-\EOF &&
|
||||
echo text >>$1
|
||||
EOF
|
||||
|
||||
test_all_match git checkout -b reset-test update-deep &&
|
||||
run_on_all ../edit-contents a &&
|
||||
test_all_match git reset --keep deepest &&
|
||||
test_all_match git status --porcelain=v2 &&
|
||||
|
||||
test_all_match git reset --hard update-deep &&
|
||||
run_on_all ../edit-contents deep/a &&
|
||||
test_all_match test_must_fail git reset --keep deepest
|
||||
'
|
||||
|
||||
test_expect_success 'reset with pathspecs inside sparse definition' '
|
||||
init_repos &&
|
||||
|
||||
write_script edit-contents <<-\EOF &&
|
||||
echo text >>$1
|
||||
EOF
|
||||
|
||||
test_all_match git checkout -b reset-test update-deep &&
|
||||
run_on_all ../edit-contents deep/a &&
|
||||
|
||||
test_all_match git reset base -- deep/a &&
|
||||
test_all_match git status --porcelain=v2 &&
|
||||
|
||||
test_all_match git reset base -- nonexistent-file &&
|
||||
test_all_match git status --porcelain=v2 &&
|
||||
|
||||
test_all_match git reset deepest -- deep &&
|
||||
test_all_match git status --porcelain=v2
|
||||
'
|
||||
|
||||
# Although the working tree differs between full and sparse checkouts after
|
||||
# reset, the state of the index is the same.
|
||||
test_expect_success 'reset with pathspecs outside sparse definition' '
|
||||
init_repos &&
|
||||
test_all_match git checkout -b reset-test base &&
|
||||
|
||||
test_sparse_match git reset update-folder1 -- folder1 &&
|
||||
git -C full-checkout reset update-folder1 -- folder1 &&
|
||||
test_sparse_match git status --porcelain=v2 &&
|
||||
test_all_match git rev-parse HEAD:folder1 &&
|
||||
|
||||
test_sparse_match git reset update-folder2 -- folder2/a &&
|
||||
git -C full-checkout reset update-folder2 -- folder2/a &&
|
||||
test_sparse_match git status --porcelain=v2 &&
|
||||
test_all_match git rev-parse HEAD:folder2/a
|
||||
'
|
||||
|
||||
test_expect_success 'reset with wildcard pathspec' '
|
||||
init_repos &&
|
||||
|
||||
test_all_match git reset update-deep -- deep\* &&
|
||||
test_all_match git ls-files -s -- deep &&
|
||||
|
||||
test_all_match git reset deepest -- deep\*\*\* &&
|
||||
test_all_match git ls-files -s -- deep &&
|
||||
|
||||
# The following `git reset`s result in updating the index on files with
|
||||
# `skip-worktree` enabled. To avoid failing due to discrepencies in reported
|
||||
# "modified" files, `test_sparse_match` reset is performed separately from
|
||||
# "full-checkout" reset, then the index contents of all repos are verified.
|
||||
|
||||
test_sparse_match git reset update-folder1 -- \*/a &&
|
||||
git -C full-checkout reset update-folder1 -- \*/a &&
|
||||
test_all_match git ls-files -s -- deep/a folder1/a &&
|
||||
|
||||
test_sparse_match git reset update-folder2 -- folder\* &&
|
||||
git -C full-checkout reset update-folder2 -- folder\* &&
|
||||
test_all_match git ls-files -s -- folder10 folder1 folder2 &&
|
||||
|
||||
test_sparse_match git reset base -- folder1/\* &&
|
||||
git -C full-checkout reset base -- folder1/\* &&
|
||||
test_all_match git ls-files -s -- folder1
|
||||
'
|
||||
|
||||
test_expect_success 'merge, cherry-pick, and rebase' '
|
||||
|
|
@ -685,11 +777,15 @@ test_expect_success 'submodule handling' '
|
|||
grep "160000 commit $(git -C initial-repo rev-parse HEAD) modules/sub" cache
|
||||
'
|
||||
|
||||
# When working with a sparse index, some commands will need to expand the
|
||||
# index to operate properly. If those commands also write the index back
|
||||
# to disk, they need to convert the index to sparse before writing.
|
||||
# This test verifies that both of these events are logged in trace2 logs.
|
||||
test_expect_success 'sparse-index is expanded and converted back' '
|
||||
init_repos &&
|
||||
|
||||
GIT_TRACE2_EVENT="$(pwd)/trace2.txt" GIT_TRACE2_EVENT_NESTING=10 \
|
||||
git -C sparse-index -c core.fsmonitor="" reset --hard &&
|
||||
git -C sparse-index reset -- folder1/a &&
|
||||
test_region index convert_to_sparse trace2.txt &&
|
||||
test_region index ensure_full_index trace2.txt
|
||||
'
|
||||
|
|
@ -757,9 +853,9 @@ test_expect_success 'sparse-index is not expanded' '
|
|||
ensure_not_expanded checkout - &&
|
||||
ensure_not_expanded switch rename-out-to-out &&
|
||||
ensure_not_expanded switch - &&
|
||||
git -C sparse-index reset --hard &&
|
||||
ensure_not_expanded reset --hard &&
|
||||
ensure_not_expanded checkout rename-out-to-out -- deep/deeper1 &&
|
||||
git -C sparse-index reset --hard &&
|
||||
ensure_not_expanded reset --hard &&
|
||||
ensure_not_expanded restore -s rename-out-to-out -- deep/deeper1 &&
|
||||
|
||||
echo >>sparse-index/README.md &&
|
||||
|
|
@ -769,6 +865,34 @@ test_expect_success 'sparse-index is not expanded' '
|
|||
echo >>sparse-index/untracked.txt &&
|
||||
ensure_not_expanded add . &&
|
||||
|
||||
for ref in update-deep update-folder1 update-folder2 update-deep
|
||||
do
|
||||
echo >>sparse-index/README.md &&
|
||||
ensure_not_expanded reset --hard $ref || return 1
|
||||
done &&
|
||||
|
||||
ensure_not_expanded reset --mixed base &&
|
||||
ensure_not_expanded reset --hard update-deep &&
|
||||
ensure_not_expanded reset --keep base &&
|
||||
ensure_not_expanded reset --merge update-deep &&
|
||||
ensure_not_expanded reset --hard &&
|
||||
|
||||
ensure_not_expanded reset base -- deep/a &&
|
||||
ensure_not_expanded reset base -- nonexistent-file &&
|
||||
ensure_not_expanded reset deepest -- deep &&
|
||||
|
||||
# Although folder1 is outside the sparse definition, it exists as a
|
||||
# directory entry in the index, so the pathspec will not force the
|
||||
# index to be expanded.
|
||||
ensure_not_expanded reset deepest -- folder1 &&
|
||||
ensure_not_expanded reset deepest -- folder1/ &&
|
||||
|
||||
# Wildcard identifies only in-cone files, no index expansion
|
||||
ensure_not_expanded reset deepest -- deep/\* &&
|
||||
|
||||
# Wildcard identifies only full sparse directories, no index expansion
|
||||
ensure_not_expanded reset deepest -- folder\* &&
|
||||
|
||||
ensure_not_expanded checkout -f update-deep &&
|
||||
test_config -C sparse-index pull.twohead ort &&
|
||||
(
|
||||
|
|
|
|||
|
|
@ -472,6 +472,23 @@ test_expect_success '--mixed refreshes the index' '
|
|||
test_cmp expect output
|
||||
'
|
||||
|
||||
test_expect_success '--mixed preserves skip-worktree' '
|
||||
echo 123 >>file2 &&
|
||||
git add file2 &&
|
||||
git update-index --skip-worktree file2 &&
|
||||
git reset --mixed HEAD >output &&
|
||||
test_must_be_empty output &&
|
||||
|
||||
cat >expect <<-\EOF &&
|
||||
Unstaged changes after reset:
|
||||
M file2
|
||||
EOF
|
||||
git update-index --no-skip-worktree file2 &&
|
||||
git add file2 &&
|
||||
git reset --mixed HEAD >output &&
|
||||
test_cmp expect output
|
||||
'
|
||||
|
||||
test_expect_success 'resetting specific path that is unmerged' '
|
||||
git rm --cached file2 &&
|
||||
F1=$(git rev-parse HEAD:file1) &&
|
||||
|
|
|
|||
|
|
@ -645,17 +645,24 @@ static void mark_ce_used_same_name(struct cache_entry *ce,
|
|||
}
|
||||
}
|
||||
|
||||
static struct cache_entry *next_cache_entry(struct unpack_trees_options *o)
|
||||
static struct cache_entry *next_cache_entry(struct unpack_trees_options *o, int *hint)
|
||||
{
|
||||
const struct index_state *index = o->src_index;
|
||||
int pos = o->cache_bottom;
|
||||
|
||||
if (*hint > pos)
|
||||
pos = *hint;
|
||||
|
||||
while (pos < index->cache_nr) {
|
||||
struct cache_entry *ce = index->cache[pos];
|
||||
if (!(ce->ce_flags & CE_UNPACKED))
|
||||
if (!(ce->ce_flags & CE_UNPACKED)) {
|
||||
*hint = pos + 1;
|
||||
return ce;
|
||||
}
|
||||
pos++;
|
||||
}
|
||||
|
||||
*hint = pos;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -1365,12 +1372,13 @@ static int unpack_callback(int n, unsigned long mask, unsigned long dirmask, str
|
|||
|
||||
/* Are we supposed to look at the index too? */
|
||||
if (o->merge) {
|
||||
int hint = -1;
|
||||
while (1) {
|
||||
int cmp;
|
||||
struct cache_entry *ce;
|
||||
|
||||
if (o->diff_index_cached)
|
||||
ce = next_cache_entry(o);
|
||||
ce = next_cache_entry(o, &hint);
|
||||
else
|
||||
ce = find_cache_entry(info, p);
|
||||
|
||||
|
|
@ -1690,7 +1698,7 @@ static int verify_absent(const struct cache_entry *,
|
|||
int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options *o)
|
||||
{
|
||||
struct repository *repo = the_repository;
|
||||
int i, ret;
|
||||
int i, hint, ret;
|
||||
static struct cache_entry *dfc;
|
||||
struct pattern_list pl;
|
||||
int free_pattern_list = 0;
|
||||
|
|
@ -1779,13 +1787,15 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
|
|||
info.pathspec = o->pathspec;
|
||||
|
||||
if (o->prefix) {
|
||||
hint = -1;
|
||||
|
||||
/*
|
||||
* Unpack existing index entries that sort before the
|
||||
* prefix the tree is spliced into. Note that o->merge
|
||||
* is always true in this case.
|
||||
*/
|
||||
while (1) {
|
||||
struct cache_entry *ce = next_cache_entry(o);
|
||||
struct cache_entry *ce = next_cache_entry(o, &hint);
|
||||
if (!ce)
|
||||
break;
|
||||
if (ce_in_traverse_path(ce, &info))
|
||||
|
|
@ -1806,8 +1816,9 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
|
|||
|
||||
/* Any left-over entries in the index? */
|
||||
if (o->merge) {
|
||||
hint = -1;
|
||||
while (1) {
|
||||
struct cache_entry *ce = next_cache_entry(o);
|
||||
struct cache_entry *ce = next_cache_entry(o, &hint);
|
||||
if (!ce)
|
||||
break;
|
||||
if (unpack_index_entry(ce, o) < 0)
|
||||
|
|
|
|||
Loading…
Reference in New Issue