mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

pathspec.h: move pathspec_needs_expanded_index() from reset.c to here

Browse Source 
Method pathspec_needs_expanded_index() in reset.c from 4d1cfc1351
(reset: make --mixed sparse-aware, 2021-11-29) is reusable when we
need to verify if the index needs to be expanded when the command
is utilizing a pathspec rather than a literal path.

Move it to pathspec.h for reusability.

Add a few items to the function so it can better serve its purpose as
a standalone public function:

* Add a check in front so if the index is not sparse, return early since
  no expansion is needed.

* It now takes an arbitrary 'struct index_state' pointer instead of
  using `the_index` and `active_cache`.

* Add documentation to the function.

Helped-by: Victoria Dye <vdye@github.com>
Helped-by: Derrick Stolee <derrickstolee@github.com>
Signed-off-by: Shaoxuan Yuan <shaoxuan.yuan02@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Shaoxuan Yuan
2022-08-07 12:13:33 +08:00
committed by Junio C Hamano
parent ba808251aa
commit b29ad38322
3 changed files with 102 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
builtin/reset.c
View File

@ -174,88 +174,6 @@ 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 know we don't need to
* expand the index.
*
* Examples:
* - in-cone/foo***: doesn't need expanded index
* - not-in-cone/bar*: may need expanded index
* - **.c: may need expanded index
*/
if (strspn(item.original + item.nowildcard_len, "*") == item.len - item.nowildcard_len &&
path_in_cone_mode_sparse_checkout(item.original, &the_index))
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, static int read_from_tree(const struct pathspec *pathspec,
struct object_id *tree_oid, struct object_id *tree_oid,
int intent_to_add) int intent_to_add)
@ -273,7 +191,7 @@ static int read_from_tree(const struct pathspec *pathspec,
opt.change = diff_change; opt.change = diff_change;
opt.add_remove = diff_addremove; opt.add_remove = diff_addremove;
if (pathspec->nr && the_index.sparse_index && pathspec_needs_expanded_index(pathspec)) if (pathspec->nr && pathspec_needs_expanded_index(&the_index, pathspec))
ensure_full_index(&the_index); ensure_full_index(&the_index);
if (do_diff_cache(tree_oid, &opt)) if (do_diff_cache(tree_oid, &opt))

89
pathspec.c
View File

@ -759,3 +759,92 @@ int match_pathspec_attrs(struct index_state *istate,
return 1; return 1;
} }
int pathspec_needs_expanded_index(struct index_state *istate,
const struct pathspec *pathspec)
{
unsigned int i, pos;
int res = 0;
char *skip_worktree_seen = NULL;
/*
* If index is not sparse, no index expansion is needed.
*/
if (!istate->sparse_index)
return 0;
/*
* 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 know we don't need to
* expand the index.
*
* Examples:
* - in-cone/foo***: doesn't need expanded index
* - not-in-cone/bar*: may need expanded index
* - **.c: may need expanded index
*/
if (strspn(item.original + item.nowildcard_len, "*") == item.len - item.nowildcard_len &&
path_in_cone_mode_sparse_checkout(item.original, istate))
continue;
for (pos = 0; pos < istate->cache_nr; pos++) {
struct cache_entry *ce = istate->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, istate) &&
!matches_skip_worktree(pathspec, i, &skip_worktree_seen))
res = 1;
if (res > 0)
break;
}
free(skip_worktree_seen);
return res;
}

12
pathspec.h
View File

@ -171,4 +171,16 @@ int match_pathspec_attrs(struct index_state *istate,
const char *name, int namelen, const char *name, int namelen,
const struct pathspec_item *item); const struct pathspec_item *item);
/*
* Determine whether a pathspec will match only entire index entries (non-sparse
* files and/or entire sparse directories). If the pathspec has the potential to
* match partial contents of a sparse directory, return 1 to indicate the index
* should be expanded to match the appropriate index entries.
*
* For the sake of simplicity, always return 1 if using a more complex "magic"
* pathspec.
*/
int pathspec_needs_expanded_index(struct index_state *istate,
const struct pathspec *pathspec);
#endif /* PATHSPEC_H */ #endif /* PATHSPEC_H */