void test_network_remote_remotes__parsing(void) { git_remote *_remote2 = NULL; cl_assert_equal_s(git_remote_name(_remote), "test"); cl_assert_equal_s(git_remote_url(_remote), "git://github.com/libgit2/libgit2"); cl_assert(git_remote_pushurl(_remote) == NULL); cl_assert_equal_s(git_remote__urlfordirection(_remote, GIT_DIRECTION_FETCH), "git://github.com/libgit2/libgit2"); cl_assert_equal_s(git_remote__urlfordirection(_remote, GIT_DIRECTION_PUSH), "git://github.com/libgit2/libgit2"); cl_git_pass(git_remote_lookup(&_remote2, _repo, "test_with_pushurl")); cl_assert_equal_s(git_remote_name(_remote2), "test_with_pushurl"); cl_assert_equal_s(git_remote_url(_remote2), "git://github.com/libgit2/fetchlibgit2"); cl_assert_equal_s(git_remote_pushurl(_remote2), "git://github.com/libgit2/pushlibgit2"); cl_assert_equal_s(git_remote__urlfordirection(_remote2, GIT_DIRECTION_FETCH), "git://github.com/libgit2/fetchlibgit2"); cl_assert_equal_s(git_remote__urlfordirection(_remote2, GIT_DIRECTION_PUSH), "git://github.com/libgit2/pushlibgit2"); git_remote_free(_remote2); }
/** * ggit_remote_get_name: * @remote: a #GgitRemote. * * Gets the remote's name. * * Returns: (transfer none) (nullable): the name of @remote or %NULL. */ const gchar * ggit_remote_get_name (GgitRemote *remote) { g_return_val_if_fail (GGIT_IS_REMOTE (remote), NULL); return git_remote_name (_ggit_native_get (remote)); }
emacs_value egit_remote_name(emacs_env *env, emacs_value _remote) { EGIT_ASSERT_REMOTE(_remote); git_remote *remote = EGIT_EXTRACT(_remote); const char *name = git_remote_name(remote); if (name) return EM_STRING(name); return em_nil; }
/* * call-seq: * remote.name() -> string * * Returns the remote's name * remote.name #=> "origin" */ static VALUE rb_git_remote_name(VALUE self) { git_remote *remote; const char * name; Data_Get_Struct(self, git_remote, remote); name = git_remote_name(remote); return name ? rb_str_new_utf8(name) : Qnil; }
void test_network_remote_remotes__tagopt(void) { const char *name = git_remote_name(_remote); git_remote_set_autotag(_repo, name, GIT_REMOTE_DOWNLOAD_TAGS_ALL); assert_config_entry_value(_repo, "remote.test.tagopt", "--tags"); git_remote_set_autotag(_repo, name, GIT_REMOTE_DOWNLOAD_TAGS_NONE); assert_config_entry_value(_repo, "remote.test.tagopt", "--no-tags"); git_remote_set_autotag(_repo, name, GIT_REMOTE_DOWNLOAD_TAGS_AUTO); assert_config_entry_existence(_repo, "remote.test.tagopt", false); }
void test_network_remote_remotes__dup(void) { git_strarray array; git_remote *dup; cl_git_pass(git_remote_dup(&dup, _remote)); cl_assert_equal_s(git_remote_name(dup), git_remote_name(_remote)); cl_assert_equal_s(git_remote_url(dup), git_remote_url(_remote)); cl_assert_equal_s(git_remote_pushurl(dup), git_remote_pushurl(_remote)); cl_git_pass(git_remote_get_fetch_refspecs(&array, _remote)); cl_assert_equal_i(1, (int)array.count); cl_assert_equal_s("+refs/heads/*:refs/remotes/test/*", array.strings[0]); git_strarray_free(&array); cl_git_pass(git_remote_get_push_refspecs(&array, _remote)); cl_assert_equal_i(0, (int)array.count); git_strarray_free(&array); git_remote_free(dup); }
void test_network_remote_remotes__pushurl(void) { const char *name = git_remote_name(_remote); git_remote *mod; cl_git_pass(git_remote_set_pushurl(_repo, name, "git://github.com/libgit2/notlibgit2")); cl_git_pass(git_remote_lookup(&mod, _repo, name)); cl_assert_equal_s(git_remote_pushurl(mod), "git://github.com/libgit2/notlibgit2"); git_remote_free(mod); cl_git_pass(git_remote_set_pushurl(_repo, name, NULL)); cl_git_pass(git_remote_lookup(&mod, _repo, name)); cl_assert(git_remote_pushurl(mod) == NULL); git_remote_free(mod); }
static int checkout_branch(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature, const char *reflog_message) { int error; if (branch) error = update_head_to_branch(repo, git_remote_name(remote), branch, signature, reflog_message); /* Point HEAD to the same ref as the remote's head */ else error = update_head_to_remote(repo, remote, signature, reflog_message); if (!error && should_checkout(repo, git_repository_is_bare(repo), co_opts)) error = git_checkout_head(repo, co_opts); return error; }
/* * call-seq: * remote.push_url = url -> url * * Sets the remote's url for pushing without persisting it in the config. * Existing connections will not be updated. * * remote.push_url = '[email protected]/libgit2/rugged.git' #=> "[email protected]/libgit2/rugged.git" */ static VALUE rb_git_remote_set_push_url(VALUE self, VALUE rb_url) { VALUE rb_repo = rugged_owner(self); git_remote *remote; git_repository *repo; rugged_check_repo(rb_repo); Data_Get_Struct(rb_repo, git_repository, repo); Check_Type(rb_url, T_STRING); Data_Get_Struct(self, git_remote, remote); rugged_exception_check( git_remote_set_pushurl(repo, git_remote_name(remote), StringValueCStr(rb_url)) ); return rb_url; }
void test_repo_init__extended_1(void) { git_reference *ref; git_remote *remote; struct stat st; git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; opts.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_NO_DOTGIT_DIR; opts.mode = GIT_REPOSITORY_INIT_SHARED_GROUP; opts.workdir_path = "../c_wd"; opts.description = "Awesomest test repository evah"; opts.initial_head = "development"; opts.origin_url = "https://github.com/libgit2/libgit2.git"; cl_git_pass(git_repository_init_ext(&_repo, "root/b/c.git", &opts)); cl_assert(!git__suffixcmp(git_repository_workdir(_repo), "/c_wd/")); cl_assert(!git__suffixcmp(git_repository_path(_repo), "/c.git/")); cl_assert(git_path_isfile("root/b/c_wd/.git")); cl_assert(!git_repository_is_bare(_repo)); /* repo will not be counted as empty because we set head to "development" */ cl_assert(!git_repository_is_empty(_repo)); cl_git_pass(git_path_lstat(git_repository_path(_repo), &st)); cl_assert(S_ISDIR(st.st_mode)); if (cl_is_chmod_supported()) cl_assert((S_ISGID & st.st_mode) == S_ISGID); else cl_assert((S_ISGID & st.st_mode) == 0); cl_git_pass(git_reference_lookup(&ref, _repo, "HEAD")); cl_assert(git_reference_type(ref) == GIT_REF_SYMBOLIC); cl_assert_equal_s("refs/heads/development", git_reference_symbolic_target(ref)); git_reference_free(ref); cl_git_pass(git_remote_lookup(&remote, _repo, "origin")); cl_assert_equal_s("origin", git_remote_name(remote)); cl_assert_equal_s(opts.origin_url, git_remote_url(remote)); git_remote_free(remote); git_repository_free(_repo); cl_fixture_cleanup("root"); }
int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_opts *co_opts, const char *branch) { int error = 0, old_fetchhead; size_t nspecs; assert(repo && remote); if (!git_repository_is_empty(repo)) { giterr_set(GITERR_INVALID, "the repository is not empty"); return -1; } if ((error = git_remote_add_fetch(remote, "refs/tags/*:refs/tags/*")) < 0) return error; old_fetchhead = git_remote_update_fetchhead(remote); git_remote_set_update_fetchhead(remote, 0); if ((error = git_remote_fetch(remote)) < 0) goto cleanup; if (branch) error = update_head_to_branch(repo, git_remote_name(remote), branch); /* Point HEAD to the same ref as the remote's head */ else error = update_head_to_remote(repo, remote); if (!error && should_checkout(repo, git_repository_is_bare(repo), co_opts)) error = git_checkout_head(repo, co_opts); cleanup: git_remote_set_update_fetchhead(remote, old_fetchhead); /* Remove the tags refspec */ nspecs = git_remote_refspec_count(remote); git_remote_remove_refspec(remote, nspecs); return error; }
void test_network_createremotethenload__parsing(void) { cl_assert_equal_s(git_remote_name(_remote), "origin"); cl_assert_equal_s(git_remote_url(_remote), url); }
PyObject * Remote_name__get__(Remote *self) { return PyUnicode_FromString(git_remote_name(self->remote)); }
void test_network_remotes__parsing(void) { cl_assert_equal_s(git_remote_name(_remote), "test"); cl_assert_equal_s(git_remote_url(_remote), "git://github.com/libgit2/libgit2"); }
bool FetchProgressCommand::Run(CGitProgressList* list, CString& sWindowTitle, int& /*m_itemCountTotal*/, int& /*m_itemCount*/) { if (!g_Git.UsingLibGit2(CGit::GIT_CMD_FETCH)) { // should never run to here ASSERT(0); return false; } list->SetWindowTitle(IDS_PROGRS_TITLE_FETCH, g_Git.m_CurrentDir, sWindowTitle); list->SetBackgroundImage(IDI_UPDATE_BKG); list->ReportCmd(CString(MAKEINTRESOURCE(IDS_PROGRS_TITLE_FETCH)) + L' ' + m_url.GetGitPathString() + L' ' + m_RefSpec); CStringA url = CUnicodeUtils::GetUTF8(m_url.GetGitPathString()); CSmartAnimation animate(list->m_pAnimate); CAutoRepository repo(g_Git.GetGitRepository()); if (!repo) { list->ReportGitError(); return false; } CAutoRemote remote; // first try with a named remote (e.g. "origin") if (git_remote_lookup(remote.GetPointer(), repo, url) < 0) { // retry with repository located at a specific url if (git_remote_create_anonymous(remote.GetPointer(), repo, url) < 0) { list->ReportGitError(); return false; } } git_fetch_options fetchopts = GIT_FETCH_OPTIONS_INIT; git_remote_callbacks& callbacks = fetchopts.callbacks; callbacks.update_tips = RemoteUpdatetipsCallback; callbacks.sideband_progress = RemoteProgressCallback; callbacks.transfer_progress = FetchCallback; callbacks.completion = RemoteCompletionCallback; callbacks.credentials = CAppUtils::Git2GetUserPassword; callbacks.certificate_check = CAppUtils::Git2CertificateCheck; CGitProgressList::Payload cbpayload = { list, repo }; callbacks.payload = &cbpayload; git_remote_set_autotag(repo, git_remote_name(remote), (git_remote_autotag_option_t)m_AutoTag); if (!m_RefSpec.IsEmpty() && git_remote_add_fetch(repo, git_remote_name(remote), CUnicodeUtils::GetUTF8(m_RefSpec))) goto error; if (git_remote_fetch(remote, nullptr, &fetchopts, nullptr) < 0) goto error; // Not setting m_PostCmdCallback here, as clone is only called from AppUtils.cpp return true; error: list->ReportGitError(); return false; }
PyObject * Remote_name__get__(Remote *self) { return to_unicode(git_remote_name(self->remote), NULL, NULL); }
void test_network_remoterename__new_name_can_contain_dots(void) { cl_git_pass(git_remote_rename(_remote, "just.renamed", dont_call_me_cb, NULL)); cl_assert_equal_s("just.renamed", git_remote_name(_remote)); }
void test_network_createremotethenload__parsing(void) { cl_assert(!strcmp(git_remote_name(_remote), "origin")); cl_assert(!strcmp(git_remote_url(_remote), url)); }
void test_network_remotes__parsing(void) { cl_assert(!strcmp(git_remote_name(remote), "test")); cl_assert(!strcmp(git_remote_url(remote), "git://github.com/libgit2/libgit2")); }
*/ #include "test_lib.h" #include "test_helpers.h" #include <git2.h> #include <posix.h> BEGIN_TEST(remotes0, "remote parsing works") git_remote *remote; git_repository *repo; git_config *cfg; 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")); must_be_true(!strcmp(git_remote_name(remote), "test")); must_be_true(!strcmp(git_remote_url(remote), "git://github.com/libgit2/libgit2")); 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));