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));