--- v4
+++ v3
@@ -1,177 +1,42 @@
From: Derrick Stolee <dstolee@microsoft.com>
-
-As we integrate the sparse index into more builtins, we occasionally
-need to check the sparse-checkout patterns to see if a path is within
-the sparse-checkout cone. Create some helper methods that help
-initialize the patterns and check for pattern matching to make this
-easier.
-
-The existing callers of commands like get_sparse_checkout_patterns() use
-a custom 'struct pattern_list' that is not necessarily the one in the
-'struct index_state', so there are not many previous uses that could
-adopt these helpers. There are just two in builtin/add.c and
-sparse-index.c that can use path_in_sparse_checkout().
-
-We add a path_in_cone_mode_sparse_checkout() as well that will only
-return false if the path is outside of the sparse-checkout definition
-_and_ the sparse-checkout patterns are in cone mode.
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
---
- builtin/add.c | 7 +------
- dir.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++
- dir.h | 8 ++++++++
- sparse-index.c | 14 +++-----------
- 4 files changed, 64 insertions(+), 17 deletions(-)
+ attr.c | 14 ++++++++++++++
+ 1 file changed, 14 insertions(+)
-diff --git a/builtin/add.c b/builtin/add.c
-index 17528e8f922..88a6c0c69fb 100644
---- a/builtin/add.c
-+++ b/builtin/add.c
-@@ -190,8 +190,6 @@ static int refresh(int verbose, const struct pathspec *pathspec)
- struct string_list only_match_skip_worktree = STRING_LIST_INIT_NODUP;
- int flags = REFRESH_IGNORE_SKIP_WORKTREE |
- (verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET);
-- struct pattern_list pl = { 0 };
-- int sparse_checkout_enabled = !get_sparse_checkout_patterns(&pl);
+diff --git a/attr.c b/attr.c
+index d029e681f28..a1009f78029 100644
+--- a/attr.c
++++ b/attr.c
+@@ -14,6 +14,7 @@
+ #include "utf8.h"
+ #include "quote.h"
+ #include "thread-utils.h"
++#include "dir.h"
- seen = xcalloc(pathspec->nr, 1);
- refresh_index(&the_index, flags, pathspec, seen,
-@@ -199,12 +197,9 @@ static int refresh(int verbose, const struct pathspec *pathspec)
- for (i = 0; i < pathspec->nr; i++) {
- if (!seen[i]) {
- const char *path = pathspec->items[i].original;
-- int dtype = DT_REG;
+ const char git_attr__true[] = "(builtin)true";
+ const char git_attr__false[] = "\0(builtin)false";
+@@ -744,6 +745,19 @@ static struct attr_stack *read_attr_from_index(struct index_state *istate,
+ if (!istate)
+ return NULL;
- if (matches_skip_worktree(pathspec, i, &skip_worktree_seen) ||
-- (sparse_checkout_enabled &&
-- !path_matches_pattern_list(path, strlen(path), NULL,
-- &dtype, &pl, &the_index))) {
-+ !path_in_sparse_checkout(path, &the_index)) {
- string_list_append(&only_match_skip_worktree,
- pathspec->items[i].original);
- } else {
-diff --git a/dir.c b/dir.c
-index 03c4d212672..86afa2eae00 100644
---- a/dir.c
-+++ b/dir.c
-@@ -1439,6 +1439,58 @@ done:
- return result;
- }
-
-+int init_sparse_checkout_patterns(struct index_state *istate)
-+{
-+ if (!core_apply_sparse_checkout)
-+ return 1;
-+ if (istate->sparse_checkout_patterns)
-+ return 0;
++ /*
++ * In the case of cone-mode sparse-checkout, getting the
++ * .gitattributes file from a directory is meaningless: all
++ * contained paths will be sparse if the .gitattributes is also
++ * sparse. In the case of a sparse index, it is critical that we
++ * don't go looking for one as it will expand the index.
++ */
++ init_sparse_checkout_patterns(istate);
++ if (istate->sparse_checkout_patterns &&
++ istate->sparse_checkout_patterns->use_cone_patterns &&
++ path_in_sparse_checkout(path, istate) == NOT_MATCHED)
++ return NULL;
+
-+ CALLOC_ARRAY(istate->sparse_checkout_patterns, 1);
-+
-+ if (get_sparse_checkout_patterns(istate->sparse_checkout_patterns) < 0) {
-+ FREE_AND_NULL(istate->sparse_checkout_patterns);
-+ return -1;
-+ }
-+
-+ return 0;
-+}
-+
-+static int path_in_sparse_checkout_1(const char *path,
-+ struct index_state *istate,
-+ int require_cone_mode)
-+{
-+ const char *base;
-+ int dtype = DT_REG;
-+
-+ /*
-+ * We default to accepting a path if there are no patterns or
-+ * they are of the wrong type.
-+ */
-+ if (init_sparse_checkout_patterns(istate) ||
-+ (require_cone_mode &&
-+ !istate->sparse_checkout_patterns->use_cone_patterns))
-+ return 1;
-+
-+ base = strrchr(path, '/');
-+ return path_matches_pattern_list(path, strlen(path), base ? base + 1 : path,
-+ &dtype,
-+ istate->sparse_checkout_patterns,
-+ istate) > 0;
-+}
-+
-+int path_in_sparse_checkout(const char *path,
-+ struct index_state *istate)
-+{
-+ return path_in_sparse_checkout_1(path, istate, 0);
-+}
-+
-+int path_in_cone_mode_sparse_checkout(const char *path,
-+ struct index_state *istate)
-+{
-+ return path_in_sparse_checkout_1(path, istate, 1);
-+}
-+
- static struct path_pattern *last_matching_pattern_from_lists(
- struct dir_struct *dir, struct index_state *istate,
- const char *pathname, int pathlen,
-diff --git a/dir.h b/dir.h
-index b3e1a54a971..6823312521e 100644
---- a/dir.h
-+++ b/dir.h
-@@ -394,6 +394,14 @@ enum pattern_match_result path_matches_pattern_list(const char *pathname,
- const char *basename, int *dtype,
- struct pattern_list *pl,
- struct index_state *istate);
-+
-+int init_sparse_checkout_patterns(struct index_state *state);
-+
-+int path_in_sparse_checkout(const char *path,
-+ struct index_state *istate);
-+int path_in_cone_mode_sparse_checkout(const char *path,
-+ struct index_state *istate);
-+
- struct dir_entry *dir_add_ignored(struct dir_struct *dir,
- struct index_state *istate,
- const char *pathname, int len);
-diff --git a/sparse-index.c b/sparse-index.c
-index 880c5f72338..23f7c3bd361 100644
---- a/sparse-index.c
-+++ b/sparse-index.c
-@@ -33,19 +33,14 @@ static int convert_to_sparse_rec(struct index_state *istate,
- {
- int i, can_convert = 1;
- int start_converted = num_converted;
-- enum pattern_match_result match;
-- int dtype = DT_UNKNOWN;
- struct strbuf child_path = STRBUF_INIT;
-- struct pattern_list *pl = istate->sparse_checkout_patterns;
-
- /*
- * Is the current path outside of the sparse cone?
- * Then check if the region can be replaced by a sparse
- * directory entry (everything is sparse and merged).
- */
-- match = path_matches_pattern_list(ct_path, ct_pathlen,
-- NULL, &dtype, pl, istate);
-- if (match != NOT_MATCHED)
-+ if (path_in_sparse_checkout(ct_path, istate))
- can_convert = 0;
-
- for (i = start; can_convert && i < end; i++) {
-@@ -152,11 +147,8 @@ int convert_to_sparse(struct index_state *istate)
- if (!istate->repo->settings.sparse_index)
- return 0;
-
-- if (!istate->sparse_checkout_patterns) {
-- istate->sparse_checkout_patterns = xcalloc(1, sizeof(struct pattern_list));
-- if (get_sparse_checkout_patterns(istate->sparse_checkout_patterns) < 0)
-- return 0;
-- }
-+ if (init_sparse_checkout_patterns(istate))
-+ return 0;
-
- /*
- * We need cone-mode patterns to use sparse-index. If a user edits
+ buf = read_blob_data_from_index(istate, path, NULL);
+ if (!buf)
+ return NULL;
--
gitgitgadget