Merge branch 'ag/rebase-p'
[git.git] / list-objects-filter.c
blob5b14d2711ad3791169f5d8cbc03836b4254bd55c
1 #include "cache.h"
2 #include "dir.h"
3 #include "tag.h"
4 #include "commit.h"
5 #include "tree.h"
6 #include "blob.h"
7 #include "diff.h"
8 #include "tree-walk.h"
9 #include "revision.h"
10 #include "list-objects.h"
11 #include "list-objects-filter.h"
12 #include "list-objects-filter-options.h"
13 #include "oidset.h"
15 /* Remember to update object flag allocation in object.h */
17 * FILTER_SHOWN_BUT_REVISIT -- we set this bit on tree objects
18 * that have been shown, but should be revisited if they appear
19 * in the traversal (until we mark it SEEN). This is a way to
20 * let us silently de-dup calls to show() in the caller. This
21 * is subtly different from the "revision.h:SHOWN" and the
22 * "sha1-name.c:ONELINE_SEEN" bits. And also different from
23 * the non-de-dup usage in pack-bitmap.c
25 #define FILTER_SHOWN_BUT_REVISIT (1<<21)
28 * A filter for list-objects to omit ALL blobs from the traversal.
29 * And to OPTIONALLY collect a list of the omitted OIDs.
31 struct filter_blobs_none_data {
32 struct oidset *omits;
35 static enum list_objects_filter_result filter_blobs_none(
36 enum list_objects_filter_situation filter_situation,
37 struct object *obj,
38 const char *pathname,
39 const char *filename,
40 void *filter_data_)
42 struct filter_blobs_none_data *filter_data = filter_data_;
44 switch (filter_situation) {
45 default:
46 die("unknown filter_situation");
47 return LOFR_ZERO;
49 case LOFS_BEGIN_TREE:
50 assert(obj->type == OBJ_TREE);
51 /* always include all tree objects */
52 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
54 case LOFS_END_TREE:
55 assert(obj->type == OBJ_TREE);
56 return LOFR_ZERO;
58 case LOFS_BLOB:
59 assert(obj->type == OBJ_BLOB);
60 assert((obj->flags & SEEN) == 0);
62 if (filter_data->omits)
63 oidset_insert(filter_data->omits, &obj->oid);
64 return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
68 static void *filter_blobs_none__init(
69 struct oidset *omitted,
70 struct list_objects_filter_options *filter_options,
71 filter_object_fn *filter_fn,
72 filter_free_fn *filter_free_fn)
74 struct filter_blobs_none_data *d = xcalloc(1, sizeof(*d));
75 d->omits = omitted;
77 *filter_fn = filter_blobs_none;
78 *filter_free_fn = free;
79 return d;
83 * A filter for list-objects to omit large blobs.
84 * And to OPTIONALLY collect a list of the omitted OIDs.
86 struct filter_blobs_limit_data {
87 struct oidset *omits;
88 unsigned long max_bytes;
91 static enum list_objects_filter_result filter_blobs_limit(
92 enum list_objects_filter_situation filter_situation,
93 struct object *obj,
94 const char *pathname,
95 const char *filename,
96 void *filter_data_)
98 struct filter_blobs_limit_data *filter_data = filter_data_;
99 unsigned long object_length;
100 enum object_type t;
102 switch (filter_situation) {
103 default:
104 die("unknown filter_situation");
105 return LOFR_ZERO;
107 case LOFS_BEGIN_TREE:
108 assert(obj->type == OBJ_TREE);
109 /* always include all tree objects */
110 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
112 case LOFS_END_TREE:
113 assert(obj->type == OBJ_TREE);
114 return LOFR_ZERO;
116 case LOFS_BLOB:
117 assert(obj->type == OBJ_BLOB);
118 assert((obj->flags & SEEN) == 0);
120 t = oid_object_info(the_repository, &obj->oid, &object_length);
121 if (t != OBJ_BLOB) { /* probably OBJ_NONE */
123 * We DO NOT have the blob locally, so we cannot
124 * apply the size filter criteria. Be conservative
125 * and force show it (and let the caller deal with
126 * the ambiguity).
128 goto include_it;
131 if (object_length < filter_data->max_bytes)
132 goto include_it;
134 if (filter_data->omits)
135 oidset_insert(filter_data->omits, &obj->oid);
136 return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
139 include_it:
140 if (filter_data->omits)
141 oidset_remove(filter_data->omits, &obj->oid);
142 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
145 static void *filter_blobs_limit__init(
146 struct oidset *omitted,
147 struct list_objects_filter_options *filter_options,
148 filter_object_fn *filter_fn,
149 filter_free_fn *filter_free_fn)
151 struct filter_blobs_limit_data *d = xcalloc(1, sizeof(*d));
152 d->omits = omitted;
153 d->max_bytes = filter_options->blob_limit_value;
155 *filter_fn = filter_blobs_limit;
156 *filter_free_fn = free;
157 return d;
161 * A filter driven by a sparse-checkout specification to only
162 * include blobs that a sparse checkout would populate.
164 * The sparse-checkout spec can be loaded from a blob with the
165 * given OID or from a local pathname. We allow an OID because
166 * the repo may be bare or we may be doing the filtering on the
167 * server.
169 struct frame {
171 * defval is the usual default include/exclude value that
172 * should be inherited as we recurse into directories based
173 * upon pattern matching of the directory itself or of a
174 * containing directory.
176 int defval;
179 * 1 if the directory (recursively) contains any provisionally
180 * omitted objects.
182 * 0 if everything (recursively) contained in this directory
183 * has been explicitly included (SHOWN) in the result and
184 * the directory may be short-cut later in the traversal.
186 unsigned child_prov_omit : 1;
189 struct filter_sparse_data {
190 struct oidset *omits;
191 struct exclude_list el;
193 size_t nr, alloc;
194 struct frame *array_frame;
197 static enum list_objects_filter_result filter_sparse(
198 enum list_objects_filter_situation filter_situation,
199 struct object *obj,
200 const char *pathname,
201 const char *filename,
202 void *filter_data_)
204 struct filter_sparse_data *filter_data = filter_data_;
205 int val, dtype;
206 struct frame *frame;
208 switch (filter_situation) {
209 default:
210 die("unknown filter_situation");
211 return LOFR_ZERO;
213 case LOFS_BEGIN_TREE:
214 assert(obj->type == OBJ_TREE);
215 dtype = DT_DIR;
216 val = is_excluded_from_list(pathname, strlen(pathname),
217 filename, &dtype, &filter_data->el,
218 &the_index);
219 if (val < 0)
220 val = filter_data->array_frame[filter_data->nr].defval;
222 ALLOC_GROW(filter_data->array_frame, filter_data->nr + 1,
223 filter_data->alloc);
224 filter_data->nr++;
225 filter_data->array_frame[filter_data->nr].defval = val;
226 filter_data->array_frame[filter_data->nr].child_prov_omit = 0;
229 * A directory with this tree OID may appear in multiple
230 * places in the tree. (Think of a directory move or copy,
231 * with no other changes, so the OID is the same, but the
232 * full pathnames of objects within this directory are new
233 * and may match is_excluded() patterns differently.)
234 * So we cannot mark this directory as SEEN (yet), since
235 * that will prevent process_tree() from revisiting this
236 * tree object with other pathname prefixes.
238 * Only _DO_SHOW the tree object the first time we visit
239 * this tree object.
241 * We always show all tree objects. A future optimization
242 * may want to attempt to narrow this.
244 if (obj->flags & FILTER_SHOWN_BUT_REVISIT)
245 return LOFR_ZERO;
246 obj->flags |= FILTER_SHOWN_BUT_REVISIT;
247 return LOFR_DO_SHOW;
249 case LOFS_END_TREE:
250 assert(obj->type == OBJ_TREE);
251 assert(filter_data->nr > 0);
253 frame = &filter_data->array_frame[filter_data->nr];
254 filter_data->nr--;
257 * Tell our parent directory if any of our children were
258 * provisionally omitted.
260 filter_data->array_frame[filter_data->nr].child_prov_omit |=
261 frame->child_prov_omit;
264 * If there are NO provisionally omitted child objects (ALL child
265 * objects in this folder were INCLUDED), then we can mark the
266 * folder as SEEN (so we will not have to revisit it again).
268 if (!frame->child_prov_omit)
269 return LOFR_MARK_SEEN;
270 return LOFR_ZERO;
272 case LOFS_BLOB:
273 assert(obj->type == OBJ_BLOB);
274 assert((obj->flags & SEEN) == 0);
276 frame = &filter_data->array_frame[filter_data->nr];
278 dtype = DT_REG;
279 val = is_excluded_from_list(pathname, strlen(pathname),
280 filename, &dtype, &filter_data->el,
281 &the_index);
282 if (val < 0)
283 val = frame->defval;
284 if (val > 0) {
285 if (filter_data->omits)
286 oidset_remove(filter_data->omits, &obj->oid);
287 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
291 * Provisionally omit it. We've already established that
292 * this pathname is not in the sparse-checkout specification
293 * with the CURRENT pathname, so we *WANT* to omit this blob.
295 * However, a pathname elsewhere in the tree may also
296 * reference this same blob, so we cannot reject it yet.
297 * Leave the LOFR_ bits unset so that if the blob appears
298 * again in the traversal, we will be asked again.
300 if (filter_data->omits)
301 oidset_insert(filter_data->omits, &obj->oid);
304 * Remember that at least 1 blob in this tree was
305 * provisionally omitted. This prevents us from short
306 * cutting the tree in future iterations.
308 frame->child_prov_omit = 1;
309 return LOFR_ZERO;
314 static void filter_sparse_free(void *filter_data)
316 struct filter_sparse_data *d = filter_data;
317 /* TODO free contents of 'd' */
318 free(d);
321 static void *filter_sparse_oid__init(
322 struct oidset *omitted,
323 struct list_objects_filter_options *filter_options,
324 filter_object_fn *filter_fn,
325 filter_free_fn *filter_free_fn)
327 struct filter_sparse_data *d = xcalloc(1, sizeof(*d));
328 d->omits = omitted;
329 if (add_excludes_from_blob_to_list(filter_options->sparse_oid_value,
330 NULL, 0, &d->el) < 0)
331 die("could not load filter specification");
333 ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc);
334 d->array_frame[d->nr].defval = 0; /* default to include */
335 d->array_frame[d->nr].child_prov_omit = 0;
337 *filter_fn = filter_sparse;
338 *filter_free_fn = filter_sparse_free;
339 return d;
342 static void *filter_sparse_path__init(
343 struct oidset *omitted,
344 struct list_objects_filter_options *filter_options,
345 filter_object_fn *filter_fn,
346 filter_free_fn *filter_free_fn)
348 struct filter_sparse_data *d = xcalloc(1, sizeof(*d));
349 d->omits = omitted;
350 if (add_excludes_from_file_to_list(filter_options->sparse_path_value,
351 NULL, 0, &d->el, NULL) < 0)
352 die("could not load filter specification");
354 ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc);
355 d->array_frame[d->nr].defval = 0; /* default to include */
356 d->array_frame[d->nr].child_prov_omit = 0;
358 *filter_fn = filter_sparse;
359 *filter_free_fn = filter_sparse_free;
360 return d;
363 typedef void *(*filter_init_fn)(
364 struct oidset *omitted,
365 struct list_objects_filter_options *filter_options,
366 filter_object_fn *filter_fn,
367 filter_free_fn *filter_free_fn);
370 * Must match "enum list_objects_filter_choice".
372 static filter_init_fn s_filters[] = {
373 NULL,
374 filter_blobs_none__init,
375 filter_blobs_limit__init,
376 filter_sparse_oid__init,
377 filter_sparse_path__init,
380 void *list_objects_filter__init(
381 struct oidset *omitted,
382 struct list_objects_filter_options *filter_options,
383 filter_object_fn *filter_fn,
384 filter_free_fn *filter_free_fn)
386 filter_init_fn init_fn;
388 assert((sizeof(s_filters) / sizeof(s_filters[0])) == LOFC__COUNT);
390 if (filter_options->choice >= LOFC__COUNT)
391 die("invalid list-objects filter choice: %d",
392 filter_options->choice);
394 init_fn = s_filters[filter_options->choice];
395 if (init_fn)
396 return init_fn(omitted, filter_options,
397 filter_fn, filter_free_fn);
398 *filter_fn = NULL;
399 *filter_free_fn = NULL;
400 return NULL;