ref-filter: add option to filter out tags, branches and remotes

Add a function called 'for_each_fullref_in()' to refs.{c,h} which
iterates through each ref for the given path without trimming the path
and also accounting for broken refs, if mentioned.

Add 'filter_ref_kind()' in ref-filter.c to check the kind of ref being
handled and return the kind to 'ref_filter_handler()', where we
discard refs which we do not need and assign the kind to needed refs.

Mentored-by: Christian Couder <christian.couder@gmail.com>
Mentored-by: Matthieu Moy <matthieu.moy@grenoble-inp.fr>
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/ref-filter.c b/ref-filter.c
index c65cd60fe52d10c1b3d0c65ffafbbf04c171b272..f046d826bde8474db2f249f5bf06d2833728841d 100644 (file)
--- a/ref-filter.c
+++ b/ref-filter.c
@@ -1190,6 +1190,34 @@ static struct ref_array_item *new_ref_array_item(const char *refname,
        return ref;
 }
 
+static int filter_ref_kind(struct ref_filter *filter, const char *refname)
+{
+       unsigned int i;
+
+       static struct {
+               const char *prefix;
+               unsigned int kind;
+       } ref_kind[] = {
+               { "refs/heads/" , FILTER_REFS_BRANCHES },
+               { "refs/remotes/" , FILTER_REFS_REMOTES },
+               { "refs/tags/", FILTER_REFS_TAGS}
+       };
+
+       if (filter->kind == FILTER_REFS_BRANCHES ||
+           filter->kind == FILTER_REFS_REMOTES ||
+           filter->kind == FILTER_REFS_TAGS)
+               return filter->kind;
+       else if (!strcmp(refname, "HEAD"))
+               return FILTER_REFS_DETACHED_HEAD;
+
+       for (i = 0; i < ARRAY_SIZE(ref_kind); i++) {
+               if (starts_with(refname, ref_kind[i].prefix))
+                       return ref_kind[i].kind;
+       }
+
+       return FILTER_REFS_OTHERS;
+}
+
 /*
  * A call-back given to for_each_ref().  Filter refs and keep them for
  * later object processing.
@@ -1200,6 +1228,7 @@ static int ref_filter_handler(const char *refname, const struct object_id *oid,
        struct ref_filter *filter = ref_cbdata->filter;
        struct ref_array_item *ref;
        struct commit *commit = NULL;
+       unsigned int kind;
 
        if (flag & REF_BAD_NAME) {
                warning("ignoring ref with broken name %s", refname);
@@ -1211,6 +1240,11 @@ static int ref_filter_handler(const char *refname, const struct object_id *oid,
                return 0;
        }
 
+       /* Obtain the current ref kind from filter_ref_kind() and ignore unwanted refs. */
+       kind = filter_ref_kind(filter, refname);
+       if (!(kind & filter->kind))
+               return 0;
+
        if (*filter->name_patterns && !match_name_as_path(filter->name_patterns, refname))
                return 0;
 
@@ -1242,6 +1276,7 @@ static int ref_filter_handler(const char *refname, const struct object_id *oid,
 
        REALLOC_ARRAY(ref_cbdata->array->items, ref_cbdata->array->nr + 1);
        ref_cbdata->array->items[ref_cbdata->array->nr++] = ref;
+       ref->kind = kind;
        return 0;
 }
 
@@ -1318,17 +1353,37 @@ int filter_refs(struct ref_array *array, struct ref_filter *filter, unsigned int
 {
        struct ref_filter_cbdata ref_cbdata;
        int ret = 0;
+       unsigned int broken = 0;
 
        ref_cbdata.array = array;
        ref_cbdata.filter = filter;
 
+       if (type & FILTER_REFS_INCLUDE_BROKEN)
+               broken = 1;
+       filter->kind = type & FILTER_REFS_KIND_MASK;
+
        /*  Simple per-ref filtering */
-       if (type & (FILTER_REFS_ALL | FILTER_REFS_INCLUDE_BROKEN))
-               ret = for_each_rawref(ref_filter_handler, &ref_cbdata);
-       else if (type & FILTER_REFS_ALL)
-               ret = for_each_ref(ref_filter_handler, &ref_cbdata);
-       else if (type)
+       if (!filter->kind)
                die("filter_refs: invalid type");
+       else {
+               /*
+                * For common cases where we need only branches or remotes or tags,
+                * we only iterate through those refs. If a mix of refs is needed,
+                * we iterate over all refs and filter out required refs with the help
+                * of filter_ref_kind().
+                */
+               if (filter->kind == FILTER_REFS_BRANCHES)
+                       ret = for_each_fullref_in("refs/heads/", ref_filter_handler, &ref_cbdata, broken);
+               else if (filter->kind == FILTER_REFS_REMOTES)
+                       ret = for_each_fullref_in("refs/remotes/", ref_filter_handler, &ref_cbdata, broken);
+               else if (filter->kind == FILTER_REFS_TAGS)
+                       ret = for_each_fullref_in("refs/tags/", ref_filter_handler, &ref_cbdata, broken);
+               else if (filter->kind & FILTER_REFS_ALL)
+                       ret = for_each_fullref_in("", ref_filter_handler, &ref_cbdata, broken);
+               if (!ret && (filter->kind & FILTER_REFS_DETACHED_HEAD))
+                       head_ref(ref_filter_handler, &ref_cbdata);
+       }
+
 
        /*  Filters that need revision walking */
        if (filter->merge_commit)

diff --git a/ref-filter.h b/ref-filter.h
index 45026d04d6d0a04ea9234f2ecb30c77564172c8f..0913ba99d6a3420bd42293180f26659b9b8393d2 100644 (file)
--- a/ref-filter.h
+++ b/ref-filter.h
@@ -13,8 +13,15 @@
 #define QUOTE_PYTHON 4
 #define QUOTE_TCL 8
 
-#define FILTER_REFS_INCLUDE_BROKEN 0x1
-#define FILTER_REFS_ALL 0x2
+#define FILTER_REFS_INCLUDE_BROKEN 0x0001
+#define FILTER_REFS_TAGS           0x0002
+#define FILTER_REFS_BRANCHES       0x0004
+#define FILTER_REFS_REMOTES        0x0008
+#define FILTER_REFS_OTHERS         0x0010
+#define FILTER_REFS_ALL            (FILTER_REFS_TAGS | FILTER_REFS_BRANCHES | \
+                                   FILTER_REFS_REMOTES | FILTER_REFS_OTHERS)
+#define FILTER_REFS_DETACHED_HEAD  0x0020
+#define FILTER_REFS_KIND_MASK      (FILTER_REFS_ALL | FILTER_REFS_DETACHED_HEAD)
 
 struct atom_value;
 
@@ -27,6 +34,7 @@ struct ref_sorting {
 struct ref_array_item {
        unsigned char objectname[20];
        int flag;
+       unsigned int kind;
        const char *symref;
        struct commit *commit;
        struct atom_value *value;
@@ -51,6 +59,7 @@ struct ref_filter {
        struct commit *merge_commit;
 
        unsigned int with_commit_tag_algo : 1;
+       unsigned int kind;
 };
 
 struct ref_filter_cbdata {

diff --git a/refs.c b/refs.c
index 84b1aff8421de069c0e89e5a145642c8efe5d412..943ac5ef519538368ac5eb49316c34ce3e36ba07 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -2108,6 +2108,15 @@ int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
        return do_for_each_ref(&ref_cache, prefix, fn, strlen(prefix), 0, cb_data);
 }
 
+int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken)
+{
+       unsigned int flag = 0;
+
+       if (broken)
+               flag = DO_FOR_EACH_INCLUDE_BROKEN;
+       return do_for_each_ref(&ref_cache, prefix, fn, 0, flag, cb_data);
+}
+
 int for_each_ref_in_submodule(const char *submodule, const char *prefix,
                each_ref_fn fn, void *cb_data)
 {

diff --git a/refs.h b/refs.h
index 6a3fa6d41d50a7a76fdb2dab4c18aaaba1d9b8eb..02676498328d348bba0a28fe023eb34909264e79 100644 (file)
--- a/refs.h
+++ b/refs.h
@@ -173,6 +173,7 @@ typedef int each_ref_fn(const char *refname,
 extern int head_ref(each_ref_fn fn, void *cb_data);
 extern int for_each_ref(each_ref_fn fn, void *cb_data);
 extern int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data);
+extern int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken);
 extern int for_each_tag_ref(each_ref_fn fn, void *cb_data);
 extern int for_each_branch_ref(each_ref_fn fn, void *cb_data);
 extern int for_each_remote_ref(each_ref_fn fn, void *cb_data);