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);
}
static int clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, int link, const git_signature *signature)
{
int error, flags;
git_repository *src;
git_buf src_odb = GIT_BUF_INIT, dst_odb = GIT_BUF_INIT, src_path = GIT_BUF_INIT;
git_buf reflog_message = GIT_BUF_INIT;
assert(repo && remote);
if (!git_repository_is_empty(repo)) {
giterr_set(GITERR_INVALID, "the repository is not empty");
return -1;
}
/*
* Let's figure out what path we should use for the source
* repo, if it's not rooted, the path should be relative to
* the repository's worktree/gitdir.
*/
if ((error = git_path_from_url_or_path(&src_path, git_remote_url(remote))) < 0)
return error;
/* Copy .git/objects/ from the source to the target */
if ((error = git_repository_open(&src, git_buf_cstr(&src_path))) < 0) {
git_buf_free(&src_path);
return error;
}
git_buf_joinpath(&src_odb, git_repository_path(src), GIT_OBJECTS_DIR);
git_buf_joinpath(&dst_odb, git_repository_path(repo), GIT_OBJECTS_DIR);
if (git_buf_oom(&src_odb) || git_buf_oom(&dst_odb)) {
error = -1;
goto cleanup;
}
flags = 0;
if (can_link(git_repository_path(src), git_repository_path(repo), link))
flags |= GIT_CPDIR_LINK_FILES;
if ((error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb),
flags, GIT_OBJECT_DIR_MODE)) < 0)
goto cleanup;
git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
if ((error = git_remote_fetch(remote, signature, git_buf_cstr(&reflog_message))) != 0)
goto cleanup;
error = checkout_branch(repo, remote, co_opts, branch, signature, git_buf_cstr(&reflog_message));
cleanup:
git_buf_free(&reflog_message);
git_buf_free(&src_path);
git_buf_free(&src_odb);
git_buf_free(&dst_odb);
git_repository_free(src);
return error;
}
void test_network_remote_local__fetch_default_reflog_message(void)
{
char *refspec_strings[] = {
"master:remotes/sloppy/master",
};
git_strarray array = {
refspec_strings,
1,
};
git_reflog *log;
const git_reflog_entry *entry;
char expected_reflog_msg[1024];
connect_to_local_repository(cl_fixture("testrepo.git"));
cl_git_pass(git_remote_fetch(remote, &array, NULL, NULL));
cl_git_pass(git_reflog_read(&log, repo, "refs/remotes/sloppy/master"));
cl_assert_equal_i(1, git_reflog_entrycount(log));
entry = git_reflog_entry_byindex(log, 0);
cl_assert_equal_s("*****@*****.**", git_reflog_entry_committer(entry)->email);
sprintf(expected_reflog_msg, "fetch %s", git_remote_url(remote));
cl_assert_equal_s(expected_reflog_msg, git_reflog_entry_message(entry));
git_reflog_free(log);
}
void test_clone_local__git_style_unc_paths(void)
{
#ifdef GIT_WIN32
git_repository *repo;
git_remote *remote;
git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
git_buf git_unc = GIT_BUF_INIT;
/* we use a fixture path because it needs to exist for us to want to clone */
const char *path = cl_fixture("testrepo.git");
cl_git_pass(git_style_unc_path(&git_unc, "localhost", path));
cl_git_pass(git_clone(&repo, git_unc.ptr, "./clone.git", &opts));
cl_git_pass(git_remote_lookup(&remote, repo, "origin"));
cl_assert_equal_s(git_unc.ptr, git_remote_url(remote));
git_remote_free(remote);
git_repository_free(repo);
git_buf_free(&git_unc);
cl_git_pass(git_futils_rmdir_r("./clone.git", NULL, GIT_RMDIR_REMOVE_FILES));
#endif
}
emacs_value egit_remote_url(emacs_env *env, emacs_value _remote)
{
EGIT_ASSERT_REMOTE(_remote);
git_remote *remote = EGIT_EXTRACT(_remote);
const char *url = git_remote_url(remote);
return EM_STRING(url);
}
/*
* call-seq:
* remote.url() -> string
*
* Returns the remote's url
* remote.url #=> "git://github.com/libgit2/rugged.git"
*/
static VALUE rb_git_remote_url(VALUE self)
{
git_remote *remote;
Data_Get_Struct(self, git_remote, remote);
return rb_str_new_utf8(git_remote_url(remote));
}
/**
* ggit_remote_get_url:
* @remote: GgitRemote.
*
* Gets the remote's url.
*
* Returns: (transfer none) (nullable): the url of @remote or %NULL.
*/
const gchar *
ggit_remote_get_url (GgitRemote *remote)
{
g_return_val_if_fail (GGIT_IS_REMOTE (remote), NULL);
return git_remote_url (_ggit_native_get (remote));
}
static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch_options *opts, const git_checkout_options *co_opts, const char *branch)
{
int error;
git_buf reflog_message = GIT_BUF_INIT;
git_fetch_options fetch_opts;
git_remote *remote;
assert(repo && _remote);
if (!git_repository_is_empty(repo)) {
git_error_set(GIT_ERROR_INVALID, "the repository is not empty");
return -1;
}
if ((error = git_remote_dup(&remote, _remote)) < 0)
return error;
memcpy(&fetch_opts, opts, sizeof(git_fetch_options));
fetch_opts.update_fetchhead = 0;
fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_buf_cstr(&reflog_message))) != 0)
goto cleanup;
error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message));
cleanup:
git_remote_free(remote);
git_buf_dispose(&reflog_message);
return error;
}
void test_remote_insteadof__url_insteadof_not_applicable(void)
{
cl_git_pass(git_repository_open(&g_repo, cl_fixture(REPO_PATH)));
cl_git_pass(git_remote_lookup(&g_remote, g_repo, REMOTE_ORIGIN));
cl_assert_equal_s(
git_remote_url(g_remote),
"https://github.com/libgit2/false.git");
}
void test_remote_insteadof__url_insteadof_applicable(void)
{
cl_git_pass(git_repository_open(&g_repo, cl_fixture(REPO_PATH)));
cl_git_pass(git_remote_lookup(&g_remote, g_repo, REMOTE_INSTEADOF));
cl_assert_equal_s(
git_remote_url(g_remote),
"http://github.com/libgit2/libgit2");
}
PyObject *
Remote_url__get__(Remote *self)
{
const char *url;
url = git_remote_url(self->remote);
if (!url)
Py_RETURN_NONE;
return to_unicode(url, NULL, NULL);
}
void test_remote_insteadof__anonymous_remote(void)
{
cl_git_pass(git_repository_open(&g_repo, cl_fixture(REPO_PATH)));
cl_git_pass(git_remote_create_anonymous(&g_remote, g_repo,
"http://example.com/libgit2/libgit2"));
cl_assert_equal_s(
git_remote_url(g_remote),
"http://github.com/libgit2/libgit2");
cl_assert_equal_p(git_remote_pushurl(g_remote), NULL);
}
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);
}
/**
* Get the remote's url
*
* @param repo S4 class git_repository
* @param remote Character vector with name of remote. NA values are
* ok and give NA values as result at corresponding index in url
* vector
* @return Character vector with url for each remote
*/
SEXP git2r_remote_url(SEXP repo, SEXP remote)
{
int err = GIT_OK;
SEXP url;
size_t len;
size_t i = 0;
git_remote *tmp_remote;
git_repository *repository = NULL;
if (git2r_arg_check_string_vec(remote))
git2r_error(__func__, NULL, "'remote'", git2r_err_string_vec_arg);
repository = git2r_repository_open(repo);
if (!repository)
git2r_error(__func__, NULL, git2r_err_invalid_repository, NULL);
len = LENGTH(remote);
PROTECT(url = allocVector(STRSXP, len));
for (; i < len; i++) {
if (NA_STRING == STRING_ELT(remote, i)) {
SET_STRING_ELT(url, i, NA_STRING);
} else {
err = git_remote_lookup(
&tmp_remote,
repository,
CHAR(STRING_ELT(remote, i)));
if (err)
goto cleanup;
SET_STRING_ELT(url, i, mkChar(git_remote_url(tmp_remote)));
git_remote_free(tmp_remote);
}
}
cleanup:
if (repository)
git_repository_free(repository);
UNPROTECT(1);
if (err)
git2r_error(__func__, giterr_last(), NULL, NULL);
return 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");
}
/*
* $ git remote add addtest http://github.com/libgit2/libgit2
*
* $ cat .git/config
* [...]
* [remote "addtest"]
* url = http://github.com/libgit2/libgit2
* fetch = +refs/heads/\*:refs/remotes/addtest/\*
*/
void test_network_remote_remotes__add(void)
{
git_remote_free(_remote);
_remote = NULL;
cl_git_pass(git_remote_create(&_remote, _repo, "addtest", "http://github.com/libgit2/libgit2"));
cl_assert_equal_i(GIT_REMOTE_DOWNLOAD_TAGS_AUTO, git_remote_autotag(_remote));
git_remote_free(_remote);
_remote = NULL;
cl_git_pass(git_remote_lookup(&_remote, _repo, "addtest"));
cl_assert_equal_i(GIT_REMOTE_DOWNLOAD_TAGS_AUTO, git_remote_autotag(_remote));
_refspec = git_vector_get(&_remote->refspecs, 0);
cl_assert_equal_s("refs/heads/*", git_refspec_src(_refspec));
cl_assert(git_refspec_force(_refspec) == 1);
cl_assert_equal_s("refs/remotes/addtest/*", git_refspec_dst(_refspec));
cl_assert_equal_s(git_remote_url(_remote), "http://github.com/libgit2/libgit2");
}
static int clone_into(git_repository *repo, git_remote *_remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature)
{
int error;
git_buf reflog_message = GIT_BUF_INIT;
git_remote *remote;
const git_remote_callbacks *callbacks;
assert(repo && _remote);
if (!git_repository_is_empty(repo)) {
giterr_set(GITERR_INVALID, "the repository is not empty");
return -1;
}
if ((error = git_remote_dup(&remote, _remote)) < 0)
return error;
callbacks = git_remote_get_callbacks(_remote);
if (!giterr__check_version(callbacks, 1, "git_remote_callbacks") &&
(error = git_remote_set_callbacks(remote, callbacks)) < 0)
goto cleanup;
if ((error = git_remote_add_fetch(remote, "refs/tags/*:refs/tags/*")) < 0)
goto cleanup;
git_remote_set_update_fetchhead(remote, 0);
git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
if ((error = git_remote_fetch(remote, signature, git_buf_cstr(&reflog_message))) != 0)
goto cleanup;
error = checkout_branch(repo, remote, co_opts, branch, signature, git_buf_cstr(&reflog_message));
cleanup:
git_remote_free(remote);
git_buf_free(&reflog_message);
return error;
}
void test_network_createremotethenload__parsing(void)
{
cl_assert(!strcmp(git_remote_name(_remote), "origin"));
cl_assert(!strcmp(git_remote_url(_remote), url));
}
void Gitarre::onPushAction ()
{
Repository *repo = Repos[RepoView->currentIndex().row()];
// TODO: Add remote selection
git_remote *remote = repo->GetRemote(0);
struct git_remote_callbacks cb = { 1,
Gitarre::sRProgressCb,
Gitarre::sRCompletionCb,
Gitarre::sRCredentialsCb,
Gitarre::sRTransferProgressCb,
Gitarre::sRUpdateTipsCb,
(void *)this
};
git_remote_set_callbacks (remote, &cb);
// fix git protocol address
const char *url = git_remote_url (remote);
if (!strncmp (url, "git@", 4))
{
int len = strlen (url) - 4;
char *_url = (char *) malloc (len + 9);
strcpy (_url, "https://");
strncpy (_url + 8, url + 4, len);
_url [len + 8] = 0;
char *sc = strrchr (_url, ':');
if (sc)
*sc = '/';
git_remote_set_url (remote, _url);
}
StatusLabel->show();
StatusLabel->setText ("Connecting to remote...");
StatusProgress->show();
StatusProgress->setRange (0,0);
git_remote_connect (remote, GIT_DIRECTION_PUSH);
if (git_remote_connected (remote))
{
git_push *push;
git_push_new (&push, remote);
git_push_add_refspec (push, "refs/heads/master:refs/heads/master");
git_push_set_callbacks (push,
Gitarre::sPPackbuilderProgressCb,
(void *)this,
Gitarre::sPTransferProgressCb,
(void *)this);
git_push_finish (push);
if (git_push_unpack_ok (push))
{
git_push_status_foreach (push, Gitarre::sPStatusForeachCb, (void *)this);
git_push_update_tips (push);
}
git_push_free (push);
git_remote_disconnect (remote);
git_remote_free (remote);
}
else
{
const git_error *error = giterr_last ();
if (error->message)
QMessageBox::warning(this, "Connect to remote", QString ("Failed to connect to ") + git_remote_url (remote) + " :\n" + error->message);
else
QMessageBox::warning(this, "Connect to remote", QString ("Failed to connect to ") + git_remote_url (remote));
}
StatusLabel->hide();
StatusProgress->hide();
}
PyObject *
Remote_url__get__(Remote *self)
{
return PyUnicode_FromString(git_remote_url(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");
}
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"));
}
int NotesModel::pull() {
git_repository *repo = NULL;
git_remote *remote = NULL;
git_merge_head *merge_head = NULL;
if (!QSettings().value("gitRemoteUrl").isValid()) {
qDebug() << "gitRemoteUrl setting invalid";
return false; }
if (QSettings().value("gitRemoteUrl") == "")
return false;
try {
//Open Repo
e(git_repository_open(&repo, notesFolder().absolutePath().toUtf8().constData()));
//List repository and add one from Settings if none exists or doesn t have same URI than settings
git_strarray remotes = {0};
git_remote_list(&remotes, repo);
if (remotes.count >= 1) {
for (size_t i = 0; i < remotes.count; i++) {
e(git_remote_load(&remote, repo, remotes.strings[i]));
qDebug() << git_remote_url(remote);
if (QSettings().value("gitRemoteUrl").isValid() && git_remote_url(remote)) {
if (strcmp(git_remote_url(remote),QSettings().value("gitRemoteUrl").toString().toUtf8().constData()) != 0) {
e(git_remote_delete(remote));
e(git_remote_create(&remote, repo, "upstream",
QSettings().value("gitRemoteUrl").toString().toUtf8().constData()));
e(git_remote_save(remote));
}
}
}
} else if (remotes.count == 0) {
e(git_remote_create(&remote, repo, "upstream",
QSettings().value("gitRemoteUrl").toString().toUtf8().constData()));
e(git_remote_save(remote));
}
e(git_remote_load(&remote, repo, "upstream"));
git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
callbacks.credentials = cred_acquire_cb;
e(git_remote_set_callbacks(remote, &callbacks));
e(git_remote_connect(remote, GIT_DIRECTION_FETCH));
int connected = git_remote_connected(remote);
if (connected)
e(git_remote_fetch(remote, NULL, NULL));
git_checkout_options checkout_opt = GIT_CHECKOUT_OPTIONS_INIT;
checkout_opt.checkout_strategy = GIT_CHECKOUT_FORCE;
checkout_opt.file_mode = 0644;
git_merge_options merge_opt = GIT_MERGE_OPTIONS_INIT;
merge_opt.file_favor = GIT_MERGE_FILE_FAVOR_UNION;
const git_remote_head **head = NULL;
size_t size = 0;
e(git_remote_ls(&head, &size, remote));
if (size <= 0)
e(-1);
git_oid oid = head[0]->oid;
e(git_merge_head_from_fetchhead(&merge_head, repo, "master", git_remote_url(remote), &oid));
e(git_merge(repo, (const git_merge_head **)(&merge_head), 1, &merge_opt, &checkout_opt));
//TRY TO COMMIT
/* Create signature */
git_signature *me = NULL;
e(git_signature_now(&me, "sparkleNotes", "*****@*****.**"));
//Tree Lookup
git_object *tree_obj;
e(git_revparse_single(&tree_obj, repo, "HEAD^{tree}"));
// Get parent commit
git_oid parentCommitId;
git_commit *parent;
git_oid remoteParentCommitId;
git_commit *remoteParent;
e(git_reference_name_to_id( &parentCommitId, repo, "ORIG_HEAD" ));
e(git_commit_lookup( &parent, repo, &parentCommitId ));
e(git_reference_name_to_id( &remoteParentCommitId, repo, "MERGE_HEAD" ));
e(git_commit_lookup( &remoteParent, repo, &remoteParentCommitId ));
if (remoteParent == parent) {
//Same commit ... nothing to merge
e(git_repository_state_cleanup(repo));
git_merge_head_free(merge_head);
git_remote_free(remote);
git_repository_free(repo);
return false;
}
const git_commit *parents [2] = { parent, remoteParent };
git_oid new_commit_id;
e(git_commit_create(
&new_commit_id,
repo,
"HEAD", /* name of ref to update */
me, /* author */
me, /* committer */
"UTF-8", /* message encoding */
"Merge remote upstream/master", /* message */
(git_tree *) tree_obj, /* root tree */
2, /* parent count */
parents)); /* parents */
git_merge_head_free(merge_head);
git_remote_free(remote);
e(git_repository_state_cleanup(repo));
git_repository_free(repo);
}
catch (int error) {
const git_error *err = giterr_last();
if (err != NULL)
qDebug() << QString::number(err->klass) + "\t" + QString(err->message);
emit this->error(QString(err->message));
giterr_clear();
git_merge_head_free(merge_head);
git_remote_free(remote);
git_repository_free(repo);
}
return true;
}
static int handle(KDriver const *driver, KImplementation const *impl, int requested)
{
char const *url = k_dictionary_get(k_implementation_get_values(impl), "href");
char const *tag = k_dictionary_get(k_implementation_get_values(impl), "tag");
char const *path = k_dictionary_get(k_implementation_get_meta(impl), "name");
git_repository* repo = NULL;
git_remote* origin = NULL;
if (git_repository_open(&repo, path) == GIT_OK)
{
if (git_remote_load(&origin, repo, "origin") != GIT_OK)
{
git_repository_free(repo);
return -1;
}
if (strcmp(url, git_remote_url(origin)) != 0)
{
giterr_set_str(GITERR_INVALID, "different origin");
git_repository_free(repo);
return -1;
}
}
else
{
if (git_repository_init(&repo, path, 0) != GIT_OK)
{
return -1;
}
if (git_remote_create(&origin, repo, "origin", url) != GIT_OK)
{
git_repository_free(repo);
return -1;
}
}
git_remote_set_update_fetchhead(origin, 0);
git_remote_set_cred_acquire_cb(origin, cred_acquire, NULL);
if (git_remote_connect(origin, GIT_DIRECTION_FETCH) != GIT_OK)
{
git_remote_free(origin);
git_repository_free(repo);
return -1;
}
if (git_remote_download(origin, transfer_progress, NULL) != GIT_OK)
{
git_remote_free(origin);
git_repository_free(repo);
return -1;
}
if (git_remote_update_tips(origin) != GIT_OK)
{
git_remote_free(origin);
git_repository_free(repo);
return -1;
}
git_object* object = NULL;
if (git_revparse_single(&object, repo, tag) != GIT_OK)
{
git_remote_free(origin);
git_repository_free(repo);
return -1;
}
if (git_repository_set_head_detached(repo, git_object_id(object)) != GIT_OK)
{
git_object_free(object);
git_remote_free(origin);
git_repository_free(repo);
return -1;
}
git_checkout_opts checkout_opts = GIT_CHECKOUT_OPTS_INIT;
checkout_opts.version = GIT_CHECKOUT_OPTS_VERSION;
checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
checkout_opts.progress_cb = checkout_progress;
checkout_opts.progress_payload = NULL;
if (git_checkout_tree(repo, object, &checkout_opts) != GIT_OK)
{
git_object_free(object);
git_remote_free(origin);
git_repository_free(repo);
return -1;
}
git_object_free(object);
git_remote_free(origin);
git_repository_free(repo);
return 0;
}
void download(KImplementation const *impl, int requested, KError *error, void *ctx)
{
KDictionary const *values = k_implementation_get_values(impl);
char const *href = k_dictionary_lookup(values, "href");
char const *tag = k_dictionary_lookup(values, "tag");
char const *path = k_implementation_get_name(impl);
git_repository *repo = NULL;
git_remote *origin = NULL;
git_object *object = NULL;
struct progress_data progress_data = {{0}};
git_checkout_opts checkout_opts = GIT_CHECKOUT_OPTS_INIT;
checkout_opts.version = GIT_CHECKOUT_OPTS_VERSION;
checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
checkout_opts.progress_cb = checkout_progress;
checkout_opts.progress_payload = &progress_data;
if (git_repository_open(&repo, path) == GIT_OK)
{
if (git_remote_load(&origin, repo, "origin") != GIT_OK)
{
k_error_set(error, giterr_last()->message);
goto repository_free;
}
if (strcmp(git_remote_url(origin), href) != 0)
{
k_error_set(error, "different origin");
goto remote_free;
}
}
else
{
if (git_repository_init(&repo, path, 0) != GIT_OK)
{
k_error_set(error, giterr_last()->message);
return;
}
if (git_remote_create(&origin, repo, "origin", href) != GIT_OK)
{
k_error_set(error, giterr_last()->message);
goto repository_free;
}
}
git_remote_set_update_fetchhead(origin, 0);
git_remote_set_cred_acquire_cb(origin, cred_acquire, NULL);
if (git_remote_connect(origin, GIT_DIRECTION_FETCH) != GIT_OK)
{
k_error_set(error, giterr_last()->message);
goto remote_free;
}
if (git_remote_download(origin, fetch_progress, &progress_data) != GIT_OK)
{
k_error_set(error, giterr_last()->message);
goto remote_disconnect;
}
if (git_remote_update_tips(origin) != GIT_OK)
{
k_error_set(error, giterr_last()->message);
goto remote_disconnect;
}
if (git_revparse_single(&object, repo, tag) != GIT_OK)
{
k_error_set(error, giterr_last()->message);
goto remote_disconnect;
}
if (git_repository_set_head_detached(repo, git_object_id(object)) != GIT_OK)
{
k_error_set(error, giterr_last()->message);
goto remote_disconnect;
}
if (git_checkout_tree(repo, object, &checkout_opts) != GIT_OK)
{
k_error_set(error, giterr_last()->message);
}
remote_disconnect:
git_remote_disconnect(origin);
remote_free:
git_remote_free(origin);
repository_free:
git_repository_free(repo);
}
void test_network_createremotethenload__parsing(void)
{
cl_assert_equal_s(git_remote_name(_remote), "origin");
cl_assert_equal_s(git_remote_url(_remote), url);
}
#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)); must_pass(git_remote_get(&remote, cfg, "test"));
static int clone_local_into(git_repository *repo, git_remote *remote, const git_fetch_options *fetch_opts, const git_checkout_options *co_opts, const char *branch, int link)
{
int error, flags;
git_repository *src;
git_buf src_odb = GIT_BUF_INIT, dst_odb = GIT_BUF_INIT, src_path = GIT_BUF_INIT;
git_buf reflog_message = GIT_BUF_INIT;
assert(repo && remote);
if (!git_repository_is_empty(repo)) {
git_error_set(GIT_ERROR_INVALID, "the repository is not empty");
return -1;
}
/*
* Let's figure out what path we should use for the source
* repo, if it's not rooted, the path should be relative to
* the repository's worktree/gitdir.
*/
if ((error = git_path_from_url_or_path(&src_path, git_remote_url(remote))) < 0)
return error;
/* Copy .git/objects/ from the source to the target */
if ((error = git_repository_open(&src, git_buf_cstr(&src_path))) < 0) {
git_buf_dispose(&src_path);
return error;
}
if (git_repository_item_path(&src_odb, src, GIT_REPOSITORY_ITEM_OBJECTS) < 0
|| git_repository_item_path(&dst_odb, repo, GIT_REPOSITORY_ITEM_OBJECTS) < 0) {
error = -1;
goto cleanup;
}
flags = 0;
if (can_link(git_repository_path(src), git_repository_path(repo), link))
flags |= GIT_CPDIR_LINK_FILES;
error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb),
flags, GIT_OBJECT_DIR_MODE);
/*
* can_link() doesn't catch all variations, so if we hit an
* error and did want to link, let's try again without trying
* to link.
*/
if (error < 0 && link) {
flags &= ~GIT_CPDIR_LINK_FILES;
error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb),
flags, GIT_OBJECT_DIR_MODE);
}
if (error < 0)
goto cleanup;
git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
if ((error = git_remote_fetch(remote, NULL, fetch_opts, git_buf_cstr(&reflog_message))) != 0)
goto cleanup;
error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message));
cleanup:
git_buf_dispose(&reflog_message);
git_buf_dispose(&src_path);
git_buf_dispose(&src_odb);
git_buf_dispose(&dst_odb);
git_repository_free(src);
return error;
}
