Commit 9c0c09f7 authored by Junio C Hamano's avatar Junio C Hamano

Merge branch 'cn/fetch-prune'

* cn/fetch-prune:
  fetch: treat --tags like refs/tags/*:refs/tags/* when pruning
  fetch: honor the user-provided refspecs when pruning refs
  remote: separate out the remote_find_tracking logic into query_refspecs
  t5510: add tests for fetch --prune
  fetch: free all the additional refspecs

Conflicts:
	remote.c
parents f384a2ed e8c1e6c7
......@@ -510,10 +510,10 @@ static int fetch_refs(struct transport *transport, struct ref *ref_map)
return ret;
}
static int prune_refs(struct transport *transport, struct ref *ref_map)
static int prune_refs(struct refspec *refs, int ref_count, struct ref *ref_map)
{
int result = 0;
struct ref *ref, *stale_refs = get_stale_heads(transport->remote, ref_map);
struct ref *ref, *stale_refs = get_stale_heads(refs, ref_count, ref_map);
const char *dangling_msg = dry_run
? _(" (%s will become dangling)\n")
: _(" (%s has become dangling)\n");
......@@ -704,8 +704,31 @@ static int do_fetch(struct transport *transport,
free_refs(ref_map);
return 1;
}
if (prune)
prune_refs(transport, ref_map);
if (prune) {
/* If --tags was specified, pretend the user gave us the canonical tags refspec */
if (tags == TAGS_SET) {
const char *tags_str = "refs/tags/*:refs/tags/*";
struct refspec *tags_refspec, *refspec;
/* Copy the refspec and add the tags to it */
refspec = xcalloc(ref_count + 1, sizeof(struct refspec));
tags_refspec = parse_fetch_refspec(1, &tags_str);
memcpy(refspec, refs, ref_count * sizeof(struct refspec));
memcpy(&refspec[ref_count], tags_refspec, sizeof(struct refspec));
ref_count++;
prune_refs(refspec, ref_count, ref_map);
ref_count--;
/* The rest of the strings belong to fetch_one */
free_refspec(1, tags_refspec);
free(refspec);
} else if (ref_count) {
prune_refs(refs, ref_count, ref_map);
} else {
prune_refs(transport->remote->fetch, transport->remote->fetch_refspec_nr, ref_map);
}
}
free_refs(ref_map);
/* if neither --no-tags nor --tags was specified, do automated tag
......@@ -888,7 +911,7 @@ static int fetch_one(struct remote *remote, int argc, const char **argv)
atexit(unlock_pack);
refspec = parse_fetch_refspec(ref_nr, refs);
exit_code = do_fetch(transport, refspec, ref_nr);
free(refspec);
free_refspec(ref_nr, refspec);
transport_disconnect(transport);
transport = NULL;
return exit_code;
......
......@@ -349,7 +349,8 @@ static int get_ref_states(const struct ref *remote_refs, struct ref_states *stat
else
string_list_append(&states->tracked, abbrev_branch(ref->name));
}
stale_refs = get_stale_heads(states->remote, fetch_map);
stale_refs = get_stale_heads(states->remote->fetch,
states->remote->fetch_refspec_nr, fetch_map);
for (ref = stale_refs; ref; ref = ref->next) {
struct string_list_item *item =
string_list_append(&states->stale, abbrev_branch(ref->name));
......
......@@ -803,59 +803,56 @@ static int match_name_with_pattern(const char *key, const char *name,
return ret;
}
char *apply_refspecs(struct refspec *refspecs, int nr_refspec,
const char *name)
static int query_refspecs(struct refspec *refs, int ref_count, struct refspec *query)
{
int i;
char *ret = NULL;
for (i = 0; i < nr_refspec; i++) {
struct refspec *refspec = refspecs + i;
if (refspec->pattern) {
if (match_name_with_pattern(refspec->src, name,
refspec->dst, &ret))
return ret;
} else if (!strcmp(refspec->src, name))
return xstrdup(refspec->dst);
}
return NULL;
}
int find_src = !query->src;
int remote_find_tracking(struct remote *remote, struct refspec *refspec)
{
int find_src = refspec->src == NULL;
char *needle, **result;
int i;
if (find_src && !query->dst)
return error("query_refspecs: need either src or dst");
if (find_src) {
if (!refspec->dst)
return error("find_tracking: need either src or dst");
needle = refspec->dst;
result = &refspec->src;
} else {
needle = refspec->src;
result = &refspec->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;
for (i = 0; i < remote->fetch_refspec_nr; i++) {
struct refspec *fetch = &remote->fetch[i];
const char *key = find_src ? fetch->dst : fetch->src;
const char *value = find_src ? fetch->src : fetch->dst;
if (!fetch->dst)
if (!refspec->dst)
continue;
if (fetch->pattern) {
if (refspec->pattern) {
if (match_name_with_pattern(key, needle, value, result)) {
refspec->force = fetch->force;
query->force = refspec->force;
return 0;
}
} else if (!strcmp(needle, key)) {
*result = xstrdup(value);
refspec->force = fetch->force;
query->force = refspec->force;
return 0;
}
}
return -1;
}
char *apply_refspecs(struct refspec *refspecs, int nr_refspec,
const char *name)
{
struct refspec query;
memset(&query, 0, sizeof(struct refspec));
query.src = (char *)name;
if (query_refspecs(refspecs, nr_refspec, &query))
return NULL;
return query.dst;
}
int remote_find_tracking(struct remote *remote, struct refspec *refspec)
{
return query_refspecs(remote->fetch, remote->fetch_refspec_nr, refspec);
}
static struct ref *alloc_ref_with_prefix(const char *prefix, size_t prefixlen,
const char *name)
{
......@@ -1659,36 +1656,47 @@ struct ref *guess_remote_head(const struct ref *head,
}
struct stale_heads_info {
struct remote *remote;
struct string_list *ref_names;
struct ref **stale_refs_tail;
struct refspec *refs;
int ref_count;
};
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;
struct refspec refspec;
memset(&refspec, 0, sizeof(refspec));
refspec.dst = (char *)refname;
if (!remote_find_tracking(info->remote, &refspec)) {
if (!((flags & REF_ISSYMREF) ||
string_list_has_string(info->ref_names, refspec.src))) {
struct ref *ref = make_linked_ref(refname, &info->stale_refs_tail);
hashcpy(ref->new_sha1, sha1);
}
struct refspec query;
memset(&query, 0, sizeof(struct refspec));
query.dst = (char *)refname;
if (query_refspecs(info->refs, info->ref_count, &query))
return 0; /* 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
* remote we consider it to be stale.
*/
if (!((flags & REF_ISSYMREF) ||
string_list_has_string(info->ref_names, query.src))) {
struct ref *ref = make_linked_ref(refname, &info->stale_refs_tail);
hashcpy(ref->new_sha1, sha1);
}
free(query.src);
return 0;
}
struct ref *get_stale_heads(struct remote *remote, struct ref *fetch_map)
struct ref *get_stale_heads(struct refspec *refs, int ref_count, struct ref *fetch_map)
{
struct ref *ref, *stale_refs = NULL;
struct string_list ref_names = STRING_LIST_INIT_NODUP;
struct stale_heads_info info;
info.remote = remote;
info.ref_names = &ref_names;
info.stale_refs_tail = &stale_refs;
info.refs = refs;
info.ref_count = ref_count;
for (ref = fetch_map; ref; ref = ref->next)
string_list_append(&ref_names, ref->name);
sort_string_list(&ref_names);
......
......@@ -164,6 +164,6 @@ struct ref *guess_remote_head(const struct ref *head,
int all);
/* Return refs which no longer exist on remote */
struct ref *get_stale_heads(struct remote *remote, struct ref *fetch_map);
struct ref *get_stale_heads(struct refspec *refs, int ref_count, struct ref *fetch_map);
#endif
......@@ -76,6 +76,56 @@ test_expect_success "fetch test for-merge" '
cut -f -2 .git/FETCH_HEAD >actual &&
test_cmp expected actual'
test_expect_success 'fetch --prune on its own works as expected' '
cd "$D" &&
git clone . prune &&
cd prune &&
git fetch origin refs/heads/master:refs/remotes/origin/extrabranch &&
git fetch --prune origin &&
test_must_fail git rev-parse origin/extrabranch
'
test_expect_success 'fetch --prune with a branch name keeps branches' '
cd "$D" &&
git clone . prune-branch &&
cd prune-branch &&
git fetch origin refs/heads/master:refs/remotes/origin/extrabranch &&
git fetch --prune origin master &&
git rev-parse origin/extrabranch
'
test_expect_success 'fetch --prune with a namespace keeps other namespaces' '
cd "$D" &&
git clone . prune-namespace &&
cd prune-namespace &&
git fetch --prune origin refs/heads/a/*:refs/remotes/origin/a/* &&
git rev-parse origin/master
'
test_expect_success 'fetch --prune --tags does not delete the remote-tracking branches' '
cd "$D" &&
git clone . prune-tags &&
cd prune-tags &&
git fetch origin refs/heads/master:refs/tags/sometag &&
git fetch --prune --tags origin &&
git rev-parse origin/master &&
test_must_fail git rev-parse somebranch
'
test_expect_success 'fetch --prune --tags with branch does not delete other remote-tracking branches' '
cd "$D" &&
git clone . prune-tags-branch &&
cd prune-tags-branch &&
git fetch origin refs/heads/master:refs/remotes/origin/extrabranch &&
git fetch --prune --tags origin master &&
git rev-parse origin/extrabranch
'
test_expect_success 'fetch tags when there is no tags' '
cd "$D" &&
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment