void test_network_remotes__save(void)
{
git_remote_free(_remote);
/* Set up the remote and save it to config */
cl_git_pass(git_remote_new(&_remote, _repo, "upstream", "git://github.com/libgit2/libgit2", NULL));
cl_git_pass(git_remote_set_fetchspec(_remote, "refs/heads/*:refs/remotes/upstream/*"));
cl_git_pass(git_remote_set_pushspec(_remote, "refs/heads/*:refs/heads/*"));
cl_git_pass(git_remote_save(_remote));
git_remote_free(_remote);
_remote = NULL;
/* Load it from config and make sure everything matches */
cl_git_pass(git_remote_load(&_remote, _repo, "upstream"));
_refspec = git_remote_fetchspec(_remote);
cl_assert(_refspec != NULL);
cl_assert_equal_s(git_refspec_src(_refspec), "refs/heads/*");
cl_assert_equal_s(git_refspec_dst(_refspec), "refs/remotes/upstream/*");
_refspec = git_remote_pushspec(_remote);
cl_assert(_refspec != NULL);
cl_assert_equal_s(git_refspec_src(_refspec), "refs/heads/*");
cl_assert_equal_s(git_refspec_dst(_refspec), "refs/heads/*");
}
static int filter_wants(git_remote *remote)
{
struct filter_payload p;
git_refspec tagspec;
int error = -1;
git_vector_clear(&remote->refs);
if (git_refspec__parse(&tagspec, GIT_REFSPEC_TAGS, true) < 0)
return error;
/*
* The fetch refspec can be NULL, and what this means is that the
* user didn't specify one. This is fine, as it means that we're
* not interested in any particular branch but just the remote's
* HEAD, which will be stored in FETCH_HEAD after the fetch.
*/
p.spec = git_remote_fetchspec(remote);
p.tagspec = &tagspec;
p.found_head = 0;
p.remote = remote;
if (git_repository_odb__weakptr(&p.odb, remote->repo) < 0)
goto cleanup;
error = git_remote_ls(remote, filter_ref__cb, &p);
cleanup:
git_refspec__free(&tagspec);
return error;
}
void test_network_remotes__set_fetchspec(void)
{
cl_git_pass(git_remote_set_fetchspec(_remote, "refs/*:refs/*"));
_refspec = git_remote_fetchspec(_remote);
cl_assert_equal_s(git_refspec_src(_refspec), "refs/*");
cl_assert_equal_s(git_refspec_dst(_refspec), "refs/*");
}
static int filter_wants(git_remote *remote)
{
git_vector list;
git_headarray refs;
git_transport *t = remote->transport;
git_repository *repo = remote->repo;
const git_refspec *spec;
int error;
unsigned int i;
error = git_vector_init(&list, 16, NULL);
if (error < GIT_SUCCESS)
return error;
error = t->ls(t, &refs);
if (error < GIT_SUCCESS) {
error = git__rethrow(error, "Failed to get remote ref list");
goto cleanup;
}
spec = git_remote_fetchspec(remote);
if (spec == NULL) {
error = git__throw(GIT_ERROR, "The remote has no fetchspec");
goto cleanup;
}
for (i = 0; i < refs.len; ++i) {
git_remote_head *head = refs.heads[i];
/* If it doesn't match the refpec, we don't want it */
error = git_refspec_src_match(spec, head->name);
if (error == GIT_ENOMATCH)
continue;
if (error < GIT_SUCCESS) {
error = git__rethrow(error, "Error matching remote ref name");
goto cleanup;
}
/* If we have the object, mark it so we don't ask for it */
if (git_odb_exists(repo->db, &head->oid))
head->local = 1;
else
remote->need_pack = 1;
error = git_vector_insert(&list, head);
if (error < GIT_SUCCESS)
goto cleanup;
}
remote->refs.len = list.length;
remote->refs.heads = (git_remote_head **) list.contents;
return GIT_SUCCESS;
cleanup:
git_vector_free(&list);
return error;
}
void test_network_remotes__initialize(void)
{
cl_fixture_sandbox(REPOSITORY_FOLDER);
cl_git_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
cl_git_pass(git_repository_config(&cfg, repo, NULL, NULL));
cl_git_pass(git_remote_get(&remote, cfg, "test"));
refspec = git_remote_fetchspec(remote);
cl_assert(refspec != NULL);
}
void test_network_remotes__initialize(void)
{
cl_fixture_sandbox("testrepo.git");
cl_git_pass(git_repository_open(&_repo, "testrepo.git"));
cl_git_pass(git_remote_load(&_remote, _repo, "test"));
_refspec = git_remote_fetchspec(_remote);
cl_assert(_refspec != NULL);
}
void test_network_remotes__add(void)
{
git_remote_free(_remote);
cl_git_pass(git_remote_add(&_remote, _repo, "addtest", "http://github.com/libgit2/libgit2"));
git_remote_free(_remote);
cl_git_pass(git_remote_load(&_remote, _repo, "addtest"));
_refspec = git_remote_fetchspec(_remote);
cl_assert(!strcmp(git_refspec_src(_refspec), "refs/heads/*"));
cl_assert(!strcmp(git_refspec_dst(_refspec), "refs/remotes/addtest/*"));
}
int git_branch_tracking(
git_reference **tracking_out,
git_reference *branch)
{
const char *remote_name, *merge_name;
git_buf buf = GIT_BUF_INIT;
int error = -1;
git_remote *remote = NULL;
const git_refspec *refspec;
assert(tracking_out && branch);
if (!git_reference_is_branch(branch))
return not_a_local_branch(branch);
if ((error = retrieve_tracking_configuration(&remote_name, branch, "branch.%s.remote")) < 0)
goto cleanup;
if ((error = retrieve_tracking_configuration(&merge_name, branch, "branch.%s.merge")) < 0)
goto cleanup;
if (strcmp(".", remote_name) != 0) {
if ((error = git_remote_load(&remote, git_reference_owner(branch), remote_name)) < 0)
goto cleanup;
refspec = git_remote_fetchspec(remote);
if (refspec == NULL
|| refspec->src == NULL
|| refspec->dst == NULL) {
error = GIT_ENOTFOUND;
goto cleanup;
}
if (git_refspec_transform_r(&buf, refspec, merge_name) < 0)
goto cleanup;
} else
if (git_buf_sets(&buf, merge_name) < 0)
goto cleanup;
error = git_reference_lookup(
tracking_out,
git_reference_owner(branch),
git_buf_cstr(&buf));
cleanup:
git_remote_free(remote);
git_buf_free(&buf);
return error;
}
void test_clone_nonetwork__custom_fetch_spec(void)
{
const git_refspec *actual_fs;
const char *spec = "+refs/heads/master:refs/heads/foo";
g_options.fetch_spec = spec;
cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
cl_git_pass(git_remote_load(&g_remote, g_repo, "origin"));
actual_fs = git_remote_fetchspec(g_remote);
cl_assert_equal_s("refs/heads/master", git_refspec_src(actual_fs));
cl_assert_equal_s("refs/heads/foo", git_refspec_dst(actual_fs));
cl_git_pass(git_reference_lookup(&g_ref, g_repo, "refs/heads/foo"));
}
PyObject *
Remote_fetchspec__get__(Remote *self)
{
PyObject* py_tuple = NULL;
const git_refspec * refspec;
refspec = git_remote_fetchspec(self->remote);
if (refspec != NULL) {
py_tuple = Py_BuildValue(
"(ss)",
git_refspec_src(refspec),
git_refspec_dst(refspec)
);
return py_tuple;
}
return Error_set(GIT_ENOTFOUND);
}
static int filter_wants(git_remote *remote)
{
int error;
struct filter_payload p;
git_vector_clear(&remote->refs);
/*
* The fetch refspec can be NULL, and what this means is that the
* user didn't specify one. This is fine, as it means that we're
* not interested in any particular branch but just the remote's
* HEAD, which will be stored in FETCH_HEAD after the fetch.
*/
p.spec = git_remote_fetchspec(remote);
p.found_head = 0;
p.remote = remote;
error = git_repository_odb__weakptr(&p.odb, remote->repo);
if (error < GIT_SUCCESS)
return error;
return remote->transport->ls(remote->transport, &filter_ref__cb, &p);
}
static int update_head_to_remote(git_repository *repo, git_remote *remote)
{
int retcode = -1;
git_remote_head *remote_head;
struct head_info head_info;
git_buf remote_master_name = GIT_BUF_INIT;
/* Did we just clone an empty repository? */
if (remote->refs.length == 0) {
return setup_tracking_config(
repo,
"master",
GIT_REMOTE_ORIGIN,
GIT_REFS_HEADS_MASTER_FILE);
}
/* Get the remote's HEAD. This is always the first ref in remote->refs. */
remote_head = NULL;
if (!remote->transport->ls(remote->transport, get_head_callback, &remote_head))
return -1;
assert(remote_head);
git_oid_cpy(&head_info.remote_head_oid, &remote_head->oid);
git_buf_init(&head_info.branchname, 16);
head_info.repo = repo;
head_info.refspec = git_remote_fetchspec(remote);
/* Determine the remote tracking reference name from the local master */
if (git_refspec_transform_r(
&remote_master_name,
head_info.refspec,
GIT_REFS_HEADS_MASTER_FILE) < 0)
return -1;
/* Check to see if the remote HEAD points to the remote master */
if (reference_matches_remote_head(git_buf_cstr(&remote_master_name), &head_info) < 0)
goto cleanup;
if (git_buf_len(&head_info.branchname) > 0) {
retcode = update_head_to_new_branch(
repo,
&head_info.remote_head_oid,
git_buf_cstr(&head_info.branchname));
goto cleanup;
}
/* Not master. Check all the other refs. */
if (git_reference_foreach(
repo,
GIT_REF_LISTALL,
reference_matches_remote_head,
&head_info) < 0)
goto cleanup;
if (git_buf_len(&head_info.branchname) > 0) {
retcode = update_head_to_new_branch(
repo,
&head_info.remote_head_oid,
git_buf_cstr(&head_info.branchname));
goto cleanup;
} else {
/* TODO: What should we do if nothing has been found?
*/
}
cleanup:
git_buf_free(&remote_master_name);
git_buf_free(&head_info.branchname);
return retcode;
}
git_remote_free(remote); git_config_free(cfg); git_repository_free(repo); END_TEST BEGIN_TEST(refspec0, "remote with refspec works") git_remote *remote; git_repository *repo; git_config *cfg; const git_refspec *refspec = NULL; must_pass(git_repository_open(&repo, REPOSITORY_FOLDER)); must_pass(git_repository_config(&cfg, repo, NULL, NULL)); must_pass(git_remote_get(&remote, cfg, "test")); refspec = git_remote_fetchspec(remote); must_be_true(refspec != NULL); must_be_true(!strcmp(git_refspec_src(refspec), "refs/heads/*")); must_be_true(!strcmp(git_refspec_dst(refspec), "refs/remotes/test/*")); git_remote_free(remote); git_config_free(cfg); git_repository_free(repo); END_TEST BEGIN_TEST(refspec1, "remote fnmatch works as expected") git_remote *remote; git_repository *repo; git_config *cfg; const git_refspec *refspec = NULL; must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));