/*
* 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.
*
* You can optionally pass in an alternative list of +refspecs+ to use instead of the push
* refspecs already configured for +remote+.
*
* 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.
*
* :update_tips ::
* A callback that will be executed each time a reference is updated remotely. It will be
* passed the +refname+, +old_oid+ and +new_oid+.
*
* 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;
git_remote *remote;
git_strarray refspecs;
git_push_options opts = GIT_PUSH_OPTIONS_INIT;
int error = 0;
struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, rb_hash_new(), 0 };
rb_scan_args(argc, argv, "01:", &rb_refspecs, &rb_options);
rugged_rb_ary_to_strarray(rb_refspecs, &refspecs);
Data_Get_Struct(self, git_remote, remote);
rugged_remote_init_callbacks_and_payload_from_options(rb_options, &opts.callbacks, &payload);
error = git_remote_push(remote, &refspecs, &opts);
xfree(refspecs.strings);
if (payload.exception)
rb_jump_tag(payload.exception);
rugged_exception_check(error);
return payload.result;
}
/*
* call-seq:
* index.remove_all(pathspec = []) -> nil
* index.remove_all(pathspec = []) { |path, pathspec| block } -> nil
*
* Remove all matching index entries.
*
* Searches +index+ for entries that match +pathspec+ and removes them
* from the index.
*
* +pathspec+ can either be a String, or an Array of Strings.
* If +pathspec+ is empty, all entries in the index will be matched.
*
* If a block is given, each matched +path+ and the +pathspec+ that matched
* it will be passed to the block. If the return value of +block+ is
* falsy, the matching item will not be removed from the index.
*/
static VALUE rb_git_index_remove_all(int argc, VALUE *argv, VALUE self)
{
VALUE rb_pathspecs = rb_ary_new();
git_index *index;
git_strarray pathspecs;
int error, exception = 0;
Data_Get_Struct(self, git_index, index);
rb_scan_args(argc, argv, "01", &rb_pathspecs);
if (NIL_P(rb_pathspecs))
rb_pathspecs = rb_ary_new();
rugged_rb_ary_to_strarray(rb_ary_to_ary(rb_pathspecs), &pathspecs);
error = git_index_remove_all(index, &pathspecs,
rb_block_given_p() ? rugged__index_matched_path_cb : NULL, &exception);
xfree(pathspecs.strings);
if (exception)
rb_jump_tag(exception);
rugged_exception_check(error);
return Qnil;
}
static void init_custom_headers(VALUE rb_options, git_strarray *custom_headers)
{
if (!NIL_P(rb_options))
{
VALUE rb_headers = rb_hash_aref(rb_options, CSTR2SYM("headers"));
rugged_rb_ary_to_strarray(rb_headers, custom_headers);
}
}
/*
* call-seq:
* remote.fetch(refspecs = nil, options = {}) -> hash
*
* Downloads new data from the remote for the given +refspecs+ and updates tips.
*
* You can optionally pass in a single or multiple alternative +refspecs+ to use instead of the fetch
* refspecs already configured for +remote+.
*
* Returns a hash containing statistics for the fetch operation.
*
* The following options can be passed in the +options+ Hash:
*
* :credentials ::
* The credentials to use for the fetch 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.
*
* :progress ::
* A callback that will be executed with the textual progress received from the remote.
* This is the text send over the progress side-band (ie. the "counting objects" output).
*
* :transfer_progress ::
* A callback that will be executed to report clone progress information. It will be passed
* the amount of +total_objects+, +indexed_objects+, +received_objects+, +local_objects+,
* +total_deltas+, +indexed_deltas+ and +received_bytes+.
*
* :update_tips ::
* A callback that will be executed each time a reference is updated locally. It will be
* passed the +refname+, +old_oid+ and +new_oid+.
*
* :message ::
* The message to insert into the reflogs. Defaults to "fetch".
*
* Example:
*
* remote = Rugged::Remote.lookup(@repo, 'origin')
* remote.fetch({
* transfer_progress: lambda { |total_objects, indexed_objects, received_objects, local_objects, total_deltas, indexed_deltas, received_bytes|
* # ...
* }
* })
*/
static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
{
git_remote *remote;
git_repository *repo;
git_strarray refspecs;
git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
char *log_message = NULL;
int error;
VALUE rb_options, rb_refspecs, rb_result = Qnil, rb_repo = rugged_owner(self);
rb_scan_args(argc, argv, "01:", &rb_refspecs, &rb_options);
rugged_rb_ary_to_strarray(rb_refspecs, &refspecs);
Data_Get_Struct(self, git_remote, remote);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
if (!NIL_P(rb_options)) {
VALUE rb_val = rb_hash_aref(rb_options, CSTR2SYM("message"));
if (!NIL_P(rb_val))
log_message = StringValueCStr(rb_val);
}
if ((error = git_remote_set_callbacks(remote, &callbacks)))
goto cleanup;
if ((error = git_remote_fetch(remote, &refspecs, log_message)) == GIT_OK) {
const git_transfer_progress *stats = git_remote_stats(remote);
rb_result = rb_hash_new();
rb_hash_aset(rb_result, CSTR2SYM("total_objects"), UINT2NUM(stats->total_objects));
rb_hash_aset(rb_result, CSTR2SYM("indexed_objects"), UINT2NUM(stats->indexed_objects));
rb_hash_aset(rb_result, CSTR2SYM("received_objects"), UINT2NUM(stats->received_objects));
rb_hash_aset(rb_result, CSTR2SYM("local_objects"), UINT2NUM(stats->local_objects));
rb_hash_aset(rb_result, CSTR2SYM("total_deltas"), UINT2NUM(stats->total_deltas));
rb_hash_aset(rb_result, CSTR2SYM("indexed_deltas"), UINT2NUM(stats->indexed_deltas));
rb_hash_aset(rb_result, CSTR2SYM("received_bytes"), INT2FIX(stats->received_bytes));
}
cleanup:
xfree(refspecs.strings);
if (payload.exception)
rb_jump_tag(payload.exception);
rugged_exception_check(error);
return rb_result;
}
/*
* call-seq:
* remote.fetch(refspecs = nil, options = {}) -> hash
*
* Downloads new data from the remote for the given +refspecs+ and updates tips.
*
* You can optionally pass in a single or multiple alternative +refspecs+ to use instead of the fetch
* refspecs already configured for +remote+.
*
* Returns a hash containing statistics for the fetch operation.
*
* The following options can be passed in the +options+ Hash:
*
* :credentials ::
* The credentials to use for the fetch 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.
*
* :headers ::
* Extra HTTP headers to include with the request (only applies to http:// or https:// remotes)
*
* :progress ::
* A callback that will be executed with the textual progress received from the remote.
* This is the text send over the progress side-band (ie. the "counting objects" output).
*
* :transfer_progress ::
* A callback that will be executed to report clone progress information. It will be passed
* the amount of +total_objects+, +indexed_objects+, +received_objects+, +local_objects+,
* +total_deltas+, +indexed_deltas+ and +received_bytes+.
*
* :update_tips ::
* A callback that will be executed each time a reference is updated locally. It will be
* passed the +refname+, +old_oid+ and +new_oid+.
*
* :certificate_check ::
* A callback that will be executed each time we validate a certificate using https. It
* will be passed the +valid+, +host_name+ and the callback should return a true/false to
* indicate if the certificate has been validated.
*
* :message ::
* The message to insert into the reflogs. Defaults to "fetch".
*
* :prune ::
* Specifies the prune mode for the fetch. +true+ remove any remote-tracking references that
* no longer exist, +false+ do not prune, +nil+ use configured settings Defaults to "nil".
*
* Example:
*
* remote = Rugged::Remote.lookup(@repo, 'origin')
* remote.fetch({
* transfer_progress: lambda { |total_objects, indexed_objects, received_objects, local_objects, total_deltas, indexed_deltas, received_bytes|
* # ...
* }
* })
*/
static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
{
git_remote *remote;
git_strarray refspecs;
git_fetch_options opts = GIT_FETCH_OPTIONS_INIT;
const git_transfer_progress *stats;
struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
char *log_message = NULL;
int error;
VALUE rb_options, rb_refspecs, rb_result = Qnil;
rb_scan_args(argc, argv, "01:", &rb_refspecs, &rb_options);
rugged_rb_ary_to_strarray(rb_refspecs, &refspecs);
Data_Get_Struct(self, git_remote, remote);
rugged_remote_init_callbacks_and_payload_from_options(rb_options, &opts.callbacks, &payload);
init_custom_headers(rb_options, &opts.custom_headers);
if (!NIL_P(rb_options)) {
VALUE rb_prune_type;
VALUE rb_val = rb_hash_aref(rb_options, CSTR2SYM("message"));
if (!NIL_P(rb_val))
log_message = StringValueCStr(rb_val);
rb_prune_type = rb_hash_aref(rb_options, CSTR2SYM("prune"));
opts.prune = parse_prune_type(rb_prune_type);
}
error = git_remote_fetch(remote, &refspecs, &opts, log_message);
xfree(refspecs.strings);
git_strarray_free(&opts.custom_headers);
if (payload.exception)
rb_jump_tag(payload.exception);
rugged_exception_check(error);
stats = git_remote_stats(remote);
rb_result = rb_hash_new();
rb_hash_aset(rb_result, CSTR2SYM("total_objects"), UINT2NUM(stats->total_objects));
rb_hash_aset(rb_result, CSTR2SYM("indexed_objects"), UINT2NUM(stats->indexed_objects));
rb_hash_aset(rb_result, CSTR2SYM("received_objects"), UINT2NUM(stats->received_objects));
rb_hash_aset(rb_result, CSTR2SYM("local_objects"), UINT2NUM(stats->local_objects));
rb_hash_aset(rb_result, CSTR2SYM("total_deltas"), UINT2NUM(stats->total_deltas));
rb_hash_aset(rb_result, CSTR2SYM("indexed_deltas"), UINT2NUM(stats->indexed_deltas));
rb_hash_aset(rb_result, CSTR2SYM("received_bytes"), INT2FIX(stats->received_bytes));
return rb_result;
}
/*
* 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.
*
* You can optionally pass in an alternative list of +refspecs+ to use instead of the push
* refspecs already configured for +remote+.
*
* 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.
*
* :update_tips ::
* A callback that will be executed each time a reference is updated remotely. It will be
* passed the +refname+, +old_oid+ and +new_oid+.
*
* 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;
VALUE rb_repo = rugged_owner(self);
git_repository *repo;
git_remote *remote;
git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
git_strarray refspecs;
git_push_options opts = GIT_PUSH_OPTIONS_INIT;
int error = 0;
struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, rb_hash_new(), 0 };
rb_scan_args(argc, argv, "01:", &rb_refspecs, &rb_options);
rugged_rb_ary_to_strarray(rb_refspecs, &refspecs);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Data_Get_Struct(self, git_remote, remote);
rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
if ((error = git_remote_set_callbacks(remote, &callbacks)))
goto cleanup;
error = git_remote_push(remote, &refspecs, &opts);
cleanup:
xfree(refspecs.strings);
if (payload.exception)
rb_jump_tag(payload.exception);
rugged_exception_check(error);
return payload.result;
}
/*
* call-seq:
* index.add_all(pathspec = [][, options]) -> nil
* index.add_all(pathspec = [][, options]) { |path, pathspec| block } -> nil
*
* Add or update index entries matching files in the working directory.
*
* Searches the working directory for files that +pathspec+ and adds them
* to +index+ (by updating an existing entry or adding a new entry).
*
* +pathspec+ can either be a String, or an Array of Strings.
* If +pathspec+ is empty, all entries in the index will be matched.
*
* Files that are ignored due to +.gitignore+ rules will be skipped,
* unless they're already have an entry in +index+.
*
* Files that are marked as the result of a merge request, will have this
* marking removed and the merge conflict information will be moved into the
* "resolve undo" (REUC) section of +index+.
*
* If a block is given, each matched +path+ and the +pathspec+ that matched
* it will be passed to the block. If the return value of +block+ is
* falsy, the matching item will not be added to the index.
*
* This method will fail in bare index instances.
*
* The following options can be passed in the +options+ Hash:
*
* :force ::
* If +true+, any +.gitignore+ rules will be ignored.
*
* :disable_pathspec_match ::
* If +true+, glob expansion will be disabled and exact matching will be forced.
*
* :check_pathspec ::
* If +true+, and the +:force+ options is +false+ or not given, exact matches
* of ignored files or files that are not already in +index+ will raise a
* Rugged::InvalidError. This emulates <code>git add -A</code>.
*/
static VALUE rb_git_index_add_all(int argc, VALUE *argv, VALUE self)
{
VALUE rb_pathspecs, rb_options;
git_index *index;
git_strarray pathspecs;
int error, exception = 0;
unsigned int flags = GIT_INDEX_ADD_DEFAULT;
Data_Get_Struct(self, git_index, index);
if (rb_scan_args(argc, argv, "02", &rb_pathspecs, &rb_options) > 1) {
Check_Type(rb_options, T_HASH);
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("force"))))
flags |= GIT_INDEX_ADD_FORCE;
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("disable_pathspec_match"))))
flags |= GIT_INDEX_ADD_DISABLE_PATHSPEC_MATCH;
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("check_pathspec"))))
flags |= GIT_INDEX_ADD_CHECK_PATHSPEC;
}
rugged_rb_ary_to_strarray(rb_pathspecs, &pathspecs);
error = git_index_add_all(index, &pathspecs, flags,
rb_block_given_p() ? rugged__index_matched_path_cb : NULL, &exception);
xfree(pathspecs.strings);
if (exception)
rb_jump_tag(exception);
rugged_exception_check(error);
return Qnil;
}
