void test_network_remote_remotes__query_refspecs(void) { git_remote *remote; git_strarray array; int i; cl_git_pass(git_remote_create_with_fetchspec(&remote, _repo, "query", "git://github.com/libgit2/libgit2", NULL)); git_remote_free(remote); for (i = 0; i < 3; i++) { cl_git_pass(git_remote_add_fetch(_repo, "query", fetch_refspecs[i])); cl_git_pass(git_remote_add_push(_repo, "query", push_refspecs[i])); } cl_git_pass(git_remote_lookup(&remote, _repo, "query")); cl_git_pass(git_remote_get_fetch_refspecs(&array, remote)); for (i = 0; i < 3; i++) { cl_assert_equal_s(fetch_refspecs[i], array.strings[i]); } git_strarray_free(&array); cl_git_pass(git_remote_get_push_refspecs(&array, remote)); for (i = 0; i < 3; i++) { cl_assert_equal_s(push_refspecs[i], array.strings[i]); } git_strarray_free(&array); git_remote_free(remote); git_remote_delete(_repo, "test"); }
int git_remote_dup(git_remote **dest, git_remote *source) { int error = 0; git_strarray refspecs = { 0 }; git_remote *remote = git__calloc(1, sizeof(git_remote)); GITERR_CHECK_ALLOC(remote); if (source->name != NULL) { remote->name = git__strdup(source->name); GITERR_CHECK_ALLOC(remote->name); } if (source->url != NULL) { remote->url = git__strdup(source->url); GITERR_CHECK_ALLOC(remote->url); } if (source->pushurl != NULL) { remote->pushurl = git__strdup(source->pushurl); GITERR_CHECK_ALLOC(remote->pushurl); } remote->transport_cb = source->transport_cb; remote->transport_cb_payload = source->transport_cb_payload; remote->repo = source->repo; remote->download_tags = source->download_tags; remote->check_cert = source->check_cert; remote->update_fetchhead = source->update_fetchhead; if (git_vector_init(&remote->refs, 32, NULL) < 0 || git_vector_init(&remote->refspecs, 2, NULL) < 0 || git_vector_init(&remote->active_refspecs, 2, NULL) < 0) { error = -1; goto cleanup; } if ((error = git_remote_get_fetch_refspecs(&refspecs, source)) < 0 || (error = git_remote_set_fetch_refspecs(remote, &refspecs)) < 0) goto cleanup; git_strarray_free(&refspecs); if ((error = git_remote_get_push_refspecs(&refspecs, source)) < 0 || (error = git_remote_set_push_refspecs(remote, &refspecs)) < 0) goto cleanup; *dest = remote; cleanup: git_strarray_free(&refspecs); if (error < 0) git__free(remote); return error; }
PyObject * Remote_push_refspecs__get__(Remote *self) { int err; git_strarray refspecs; PyObject *new_list; err = git_remote_get_push_refspecs(&refspecs, self->remote); if (err != GIT_OK) return Error_set(err); new_list = get_pylist_from_git_strarray(&refspecs); git_strarray_free(&refspecs); return new_list; }
emacs_value egit_remote_get_refspecs(emacs_env *env, emacs_value _remote, emacs_value dir) { EGIT_ASSERT_REMOTE(_remote); git_remote *remote = EGIT_EXTRACT(_remote); git_strarray out = {NULL, 0}; int retval; if (EM_EQ(dir, em_fetch)) retval = git_remote_get_fetch_refspecs(&out, remote); else if (EM_EQ(dir, em_push)) retval = git_remote_get_push_refspecs(&out, remote); else { em_signal_wrong_value(env, dir); return em_nil; } EGIT_CHECK_ERROR(retval); EGIT_RET_STRARRAY(out); }
static VALUE rb_git_remote_refspecs(VALUE self, git_direction direction) { git_remote *remote; int error = 0; git_strarray refspecs; VALUE rb_refspec_array; Data_Get_Struct(self, git_remote, remote); if (direction == GIT_DIRECTION_FETCH) error = git_remote_get_fetch_refspecs(&refspecs, remote); else error = git_remote_get_push_refspecs(&refspecs, remote); rugged_exception_check(error); rb_refspec_array = rugged_strarray_to_rb_ary(&refspecs); git_strarray_free(&refspecs); return rb_refspec_array; }
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); }
/* * call-seq: * remote.push(refspecs = nil, options = {}) -> hash * * Pushes the given +refspecs+ to the given +remote+. Returns a hash that contains * key-value pairs that reflect pushed refs and error messages, if applicable. * * The following options can be passed in the +options+ Hash: * * :credentials :: * The credentials to use for the push operation. Can be either an instance of one * of the Rugged::Credentials types, or a proc returning one of the former. * The proc will be called with the +url+, the +username+ from the url (if applicable) and * a list of applicable credential types. * * :message :: * A single line log message to be appended to the reflog of each local remote-tracking * branch that gets updated. Defaults to: "fetch". * * :signature :: * The signature to be used for populating the reflog entries. * * Example: * * remote = Rugged::Remote.lookup(@repo, 'origin') * remote.push(["refs/heads/master", ":refs/heads/to_be_deleted"]) */ static VALUE rb_git_remote_push(int argc, VALUE *argv, VALUE self) { VALUE rb_refspecs, rb_options, rb_val; VALUE rb_repo = rugged_owner(self); VALUE rb_exception = Qnil, rb_result = rb_hash_new(); git_repository *repo; git_remote *remote, *tmp_remote = NULL; git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT; git_push *push = NULL; git_signature *signature = NULL; int error = 0, i = 0; char *log_message = NULL; struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, 0 }; rb_scan_args(argc, argv, "01:", &rb_refspecs, &rb_options); if (!NIL_P(rb_refspecs)) { Check_Type(rb_refspecs, T_ARRAY); for (i = 0; i < RARRAY_LEN(rb_refspecs); ++i) { VALUE rb_refspec = rb_ary_entry(rb_refspecs, i); Check_Type(rb_refspec, T_STRING); } } rugged_check_repo(rb_repo); Data_Get_Struct(rb_repo, git_repository, repo); Data_Get_Struct(self, git_remote, remote); if (!NIL_P(rb_options)) { rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload); rb_val = rb_hash_aref(rb_options, CSTR2SYM("message")); if (!NIL_P(rb_val)) log_message = StringValueCStr(rb_val); rb_val = rb_hash_aref(rb_options, CSTR2SYM("signature")); if (!NIL_P(rb_val)) signature = rugged_signature_get(rb_val, repo); } // Create a temporary remote that we use for pushing if ((error = git_remote_dup(&tmp_remote, remote)) || (error = git_remote_set_callbacks(tmp_remote, &callbacks))) goto cleanup; if (!NIL_P(rb_refspecs)) { git_remote_clear_refspecs(tmp_remote); for (i = 0; !error && i < RARRAY_LEN(rb_refspecs); ++i) { VALUE rb_refspec = rb_ary_entry(rb_refspecs, i); if ((error = git_remote_add_push(tmp_remote, StringValueCStr(rb_refspec)))) goto cleanup; } } if ((error = git_push_new(&push, tmp_remote))) goto cleanup; // TODO: Get rid of this once git_remote_push lands in libgit2. { git_strarray push_refspecs; size_t i; if ((error = git_remote_get_push_refspecs(&push_refspecs, tmp_remote))) goto cleanup; if (push_refspecs.count == 0) { rb_exception = rb_exc_new2(rb_eRuggedError, "no pushspecs are configured for the given remote"); goto cleanup; } for (i = 0; !error && i < push_refspecs.count; ++i) { error = git_push_add_refspec(push, push_refspecs.strings[i]); } git_strarray_free(&push_refspecs); if (error) goto cleanup; } if ((error = git_push_finish(push))) goto cleanup; if (!git_push_unpack_ok(push)) { rb_exception = rb_exc_new2(rb_eRuggedError, "the remote side did not unpack successfully"); goto cleanup; } if ((error = git_push_status_foreach(push, &push_status_cb, (void *)rb_result)) || (error = git_push_update_tips(push, signature, log_message))) goto cleanup; cleanup: git_push_free(push); git_remote_free(tmp_remote); git_signature_free(signature); if (!NIL_P(rb_exception)) rb_exc_raise(rb_exception); rugged_exception_check(error); return rb_result; }
int cmd_push(git_repository *repo, int argc, char **argv) { int err = GIT_OK; int i; int rc = EXIT_FAILURE; git_strarray refs = {NULL, 0}; git_push_options push_options = GIT_PUSH_OPTIONS_INIT; git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT; char *ref_fullname = NULL; git_remote *r = NULL; for (i=1;i<argc;i++) { if (argv[i][0] == '-') { fprintf(stderr,"Unknown option \"%s\"\n",argv[i]); goto out; } if (r) { git_reference *ref; if (refs.count) { fprintf(stderr, "USAGE: %s <remote> <refspec>\n", argv[0]); goto out; } if (!git_reference_dwim(&ref, repo, argv[i])) { ref_fullname = strdup(git_reference_name(ref)); refs.strings = &ref_fullname; git_reference_free(ref); } else { refs.strings = &argv[i]; } refs.count = 1; } else { if ((err = git_remote_lookup(&r,repo,argv[i])) != GIT_OK) goto out; } } if (!r) { fprintf(stderr,"No remote given!\n"); goto out; } if (refs.count == 0) { git_strarray cfg_refs; if ((err = git_remote_get_push_refspecs(&cfg_refs, r))) goto out; if (!cfg_refs.count) { fprintf(stderr, "No refspec given and no refspec configured. " "Pushing is probably a noop.\n"); } git_strarray_free(&cfg_refs); } callbacks.credentials = cred_acquire_cb; callbacks.push_update_reference = push_update_reference_callback; callbacks.certificate_check = certificate_check; push_options.callbacks = callbacks; if ((err = git_remote_push(r, &refs, &push_options))) goto out; out: if (err != GIT_OK) libgit_error(); free(ref_fullname); if (r) git_remote_free(r); return rc; }