fetch: handle overlaping refspecs on --prune

We need to consider that a remote-tracking branch may match more than
one rhs of a fetch refspec. In such a case, it is not enough to stop at
the first match but look at all of the matches in order to determine
whether a head is stale.

To this goal, introduce a variant of query_refspecs which returns all of
the matching refspecs and loop over those answers to check for
staleness.

Signed-off-by: Carlos Martín Nieto <cmn@elego.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/remote.c b/remote.c
index 9f1a8aa2c499ae5d2eb8f76f8218eb62937eea51..fde7b52f9340fd5c2517f0f48532bb0f1f169ac8 100644 (file)
--- a/remote.c
+++ b/remote.c
@@ -821,6 +821,32 @@ static int match_name_with_pattern(const char *key, const char *name,
        return ret;
 }
 
        return ret;
 }
 

+static void query_refspecs_multiple(struct refspec *refs, int ref_count, struct refspec *query, struct string_list *results)
+{
+       int i;
+       int find_src = !query->src;
+
+       if (find_src && !query->dst)
+               error("query_refspecs_multiple: need either src or dst");
+
+       for (i = 0; i < ref_count; i++) {
+               struct refspec *refspec = &refs[i];
+               const char *key = find_src ? refspec->dst : refspec->src;
+               const char *value = find_src ? refspec->src : refspec->dst;
+               const char *needle = find_src ? query->dst : query->src;
+               char **result = find_src ? &query->src : &query->dst;
+
+               if (!refspec->dst)
+                       continue;
+               if (refspec->pattern) {
+                       if (match_name_with_pattern(key, needle, value, result))
+                               string_list_append_nodup(results, *result);
+               } else if (!strcmp(needle, key)) {
+                       string_list_append(results, value);
+               }
+       }
+}
+

 static int query_refspecs(struct refspec *refs, int ref_count, struct refspec *query)
 {
        int i;
 static int query_refspecs(struct refspec *refs, int ref_count, struct refspec *query)
 {
        int i;


@@ -1954,25 +1980,37 @@ static int get_stale_heads_cb(const char *refname,
        const unsigned char *sha1, int flags, void *cb_data)
 {
        struct stale_heads_info *info = cb_data;
        const unsigned char *sha1, int flags, void *cb_data)
 {
        struct stale_heads_info *info = cb_data;

+       struct string_list matches = STRING_LIST_INIT_DUP;

        struct refspec query;
        struct refspec query;

+       int i, stale = 1;

        memset(&query, 0, sizeof(struct refspec));
        query.dst = (char *)refname;
 
        memset(&query, 0, sizeof(struct refspec));
        query.dst = (char *)refname;
 

-       if (query_refspecs(info->refs, info->ref_count, &query))
-               return 0; /* No matches */
+       query_refspecs_multiple(info->refs, info->ref_count, &query, &matches);
+       if (matches.nr == 0)
+               goto clean_exit; /* No matches */

 
        /*
         * If we did find a suitable refspec and it's not a symref and
         * it's not in the list of refs that currently exist in that
 
        /*
         * If we did find a suitable refspec and it's not a symref and
         * it's not in the list of refs that currently exist in that

-        * remote we consider it to be stale.
+        * remote, we consider it to be stale. In order to deal with
+        * overlapping refspecs, we need to go over all of the
+        * matching refs.

         */
         */

-       if (!((flags & REF_ISSYMREF) ||
-             string_list_has_string(info->ref_names, query.src))) {
+       if (flags & REF_ISSYMREF)
+               goto clean_exit;
+
+       for (i = 0; stale && i < matches.nr; i++)
+               if (string_list_has_string(info->ref_names, matches.items[i].string))
+                       stale = 0;
+
+       if (stale) {

                struct ref *ref = make_linked_ref(refname, &info->stale_refs_tail);
                hashcpy(ref->new_sha1, sha1);
        }
 
                struct ref *ref = make_linked_ref(refname, &info->stale_refs_tail);
                hashcpy(ref->new_sha1, sha1);
        }
 

-       free(query.src);
+clean_exit:
+       string_list_clear(&matches, 0);

        return 0;
 }
 
        return 0;
 }
 

diff --git a/t/t5510-fetch.sh b/t/t5510-fetch.sh
index 473e855c9185468a8e1e78ad9205bd773d5bcffb..06161280b52a562bdcaf715a8e6e2b6dfcb2bd62 100755 (executable)
--- a/t/t5510-fetch.sh
+++ b/t/t5510-fetch.sh
@@ -113,7 +113,7 @@ test_expect_success 'fetch --prune with a namespace keeps other namespaces' '
        git rev-parse origin/master
 '
 
        git rev-parse origin/master
 '
 

-test_expect_failure 'fetch --prune handles overlapping refspecs' '
+test_expect_success 'fetch --prune handles overlapping refspecs' '

        cd "$D" &&
        git update-ref refs/pull/42/head master &&
        git clone . prune-overlapping &&
        cd "$D" &&
        git update-ref refs/pull/42/head master &&
        git clone . prune-overlapping &&