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@xxxxxxxxxx>
Helped-by: Derrick Stolee <derrickstolee@xxxxxxxxxx>
Signed-off-by: Shaoxuan Yuan <shaoxuan.yuan02@xxxxxxxxx>
---
builtin/reset.c | 84 +---------------------------------------------
pathspec.c | 89 +++++++++++++++++++++++++++++++++++++++++++++++++
pathspec.h | 12 +++++++
3 files changed, 102 insertions(+), 83 deletions(-)
diff --git a/builtin/reset.c b/builtin/reset.c
index 344fff8f3a..fdce6f8c85 100644
--- a/builtin/reset.c
+++ b/builtin/reset.c
@@ -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,
struct object_id *tree_oid,
int intent_to_add)
@@ -273,7 +191,7 @@ static int read_from_tree(const struct pathspec *pathspec,
opt.change = diff_change;
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);
if (do_diff_cache(tree_oid, &opt))
diff --git a/pathspec.c b/pathspec.c
index 84ad9c73cf..46e77a85fe 100644
--- a/pathspec.c
+++ b/pathspec.c
@@ -759,3 +759,92 @@ int match_pathspec_attrs(struct index_state *istate,
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;
+}
diff --git a/pathspec.h b/pathspec.h
index 402ebb8080..41f6adfbb4 100644
--- a/pathspec.h
+++ b/pathspec.h
@@ -171,4 +171,16 @@ int match_pathspec_attrs(struct index_state *istate,
const char *name, int namelen,
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 */
--
2.37.0
