/*
* call-seq:
* tag.target -> git_object
*/
static VALUE rb_git_tag_target(VALUE self)
{
git_reference *ref, *resolved_ref;
git_repository *repo;
git_object *target;
int error;
VALUE rb_repo = rugged_owner(self);
rugged_check_repo(rb_repo);
Data_Get_Struct(self, git_reference, ref);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_reference_resolve(&resolved_ref, ref);
rugged_exception_check(error);
error = git_object_lookup(&target, repo, git_reference_target(resolved_ref), GIT_OBJ_ANY);
git_reference_free(resolved_ref);
rugged_exception_check(error);
if (git_object_type(target) == GIT_OBJ_TAG) {
git_object *annotation_target;
error = git_tag_target(&annotation_target, (git_tag *)target);
git_object_free(target);
rugged_exception_check(error);
return rugged_object_new(rb_repo, annotation_target);
} else {
return rugged_object_new(rb_repo, target);
}
}
/*
* call-seq:
* branches.create(name, target, options = {}) -> branch
*
* Create a new branch with the given +name+, pointing to the +target+.
*
* +name+ needs to be a branch name, not an absolute reference path
* (e.g. +development+ instead of +refs/heads/development+).
*
* +target+ needs to be an existing commit in the given repository.
*
* The following options can be passed in the +options+ Hash:
*
* :force ::
* Overwrites the branch with the given +name+, if it already exists,
* instead of raising an exception.
*
* If a branch with the given +name+ already exists and +:force+ is not +true+,
* an exception will be raised.
*
* Returns a Rugged::Branch for the newly created branch.
*/
static VALUE rb_git_branch_collection_create(int argc, VALUE *argv, VALUE self)
{
VALUE rb_repo = rugged_owner(self), rb_name, rb_target, rb_options;
git_repository *repo;
git_reference *branch;
git_commit *target;
int error, force = 0;
rb_scan_args(argc, argv, "20:", &rb_name, &rb_target, &rb_options);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Check_Type(rb_name, T_STRING);
Check_Type(rb_target, T_STRING);
if (!NIL_P(rb_options)) {
force = RTEST(rb_hash_aref(rb_options, CSTR2SYM("force")));
}
target = (git_commit *)rugged_object_get(repo, rb_target, GIT_OBJ_COMMIT);
error = git_branch_create(&branch, repo, StringValueCStr(rb_name), target, force);
git_commit_free(target);
rugged_exception_check(error);
return rugged_branch_new(rb_repo, branch);
}
/*
* call-seq:
* Blob.from_chunks(repository, io [, hint_path]) -> oid
*
* Write a loose blob to the +repository+ from a provider
* of chunks of data.
*
* The repository can be bare or not.
*
* The data provider +io+ should respond to a <code>read(size)</code>
* method. Generally any instance of a class based on Ruby's +IO+ class
* should work(ex. +File+). On each +read+ call it should
* return a +String+ with maximum size of +size+.
*
* *NOTE:* If an exception is raised in the +io+ object's
* +read+ method, a blob will be created with the data up to that point
* and the exception will be rescued.
* It's recommended to compare the +blob.size+ with the expected data size
* to check if all the data was written.
*
* Provided the +hint_path+ parameter is given, its value
* will help to determine what git filters should be applied
* to the object before it can be placed to the object database.
*
* File.open('/path/to/file') do |file|
* Blob.from_chunks(repo, file, 'hint/blob.h') #=> '42cab3c0cde61e2b5a2392e1eadbeffa20ffa171'
* end
*/
static VALUE rb_git_blob_from_chunks(int argc, VALUE *argv, VALUE klass)
{
VALUE rb_repo, rb_io, rb_hint_path;
const char * hint_path = NULL;
int error;
git_oid oid;
git_repository *repo;
rb_scan_args(argc, argv, "21", &rb_repo, &rb_io, &rb_hint_path);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
if (!NIL_P(rb_hint_path)) {
Check_Type(rb_hint_path, T_STRING);
hint_path = StringValueCStr(rb_hint_path);
}
error = git_blob_create_fromchunks(
&oid,
repo,
hint_path,
cb_blob__get__chunk,
(void *)rb_io);
rugged_exception_check(error);
return rugged_create_oid(&oid);
}
/*
* call-seq:
* Commit.create_with_signature(repo, content, signature, field_name = "gpgsig") -> oid
*
* Create a commit from the +content+ string and the +signature+,
* adding this data to the +field_name+ header field in the resulting
* commit.
*
* Returns the new commit's object id.
*
*/
static VALUE rb_git_commit_create_with_signature(int argc, VALUE *argv, VALUE self)
{
int error;
git_oid id;
const char *field = NULL;
git_repository *repo;
VALUE rb_repo, rb_content, rb_signature, rb_field = Qnil;
rb_scan_args(argc, argv, "31", &rb_repo, &rb_content, &rb_signature, &rb_field);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Check_Type(rb_content, T_STRING);
Check_Type(rb_signature, T_STRING);
if (!NIL_P(rb_field)) {
Check_Type(rb_field, T_STRING);
field = StringValueCStr(rb_field);
}
error = git_commit_create_with_signature(&id, repo, StringValueCStr(rb_content), StringValueCStr(rb_signature), field);
rugged_exception_check(error);
return rugged_create_oid(&id);
}
/*
* call-seq:
* tags[name] -> tag
*
* Lookup a tag in +repo+, with the given +name+.
*
* +name+ can be a short or canonical tag name
* (e.g. +v0.1.0+ or +refs/tags/v0.1.0+).
*
* Returns the looked up tag, or +nil+ if the tag doesn't exist.
*/
static VALUE rb_git_tag_collection_aref(VALUE self, VALUE rb_name)
{
git_reference *tag;
git_repository *repo;
int error;
VALUE rb_repo = rugged_owner(self);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Check_Type(rb_name, T_STRING);
error = git_reference_lookup(&tag, repo, StringValueCStr(rb_name));
if (error == GIT_ENOTFOUND || error == GIT_EINVALIDSPEC) {
char *canonical_ref = xmalloc((RSTRING_LEN(rb_name) + strlen("refs/tags/") + 1) * sizeof(char));
strcpy(canonical_ref, "refs/tags/");
strcat(canonical_ref, StringValueCStr(rb_name));
error = git_reference_lookup(&tag, repo, canonical_ref);
xfree(canonical_ref);
if (error == GIT_ENOTFOUND)
return Qnil;
}
rugged_exception_check(error);
return rugged_ref_new(rb_cRuggedTag, rb_repo, tag);
}
static void get_annotated_commit(git_annotated_commit **annotated_commit, VALUE rb_repo, VALUE rb_value)
{
git_repository *repo;
int error;
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
if (rb_obj_is_kind_of(rb_value, rb_cRuggedCommit)) {
const git_commit * commit;
const git_oid * oid;
Data_Get_Struct(rb_value, git_commit, commit);
oid = git_commit_id(commit);
error = git_annotated_commit_lookup(annotated_commit, repo, oid);
} else if (rb_obj_is_kind_of(rb_value, rb_cRuggedReference)) {
const git_reference * ref;
Data_Get_Struct(rb_value, git_reference, ref);
error = git_annotated_commit_from_ref(annotated_commit, repo, ref);
} else if (TYPE(rb_value) == T_STRING) {
error = git_annotated_commit_from_revspec(annotated_commit, repo, StringValueCStr(rb_value));
} else {
rb_raise(rb_eTypeError, "Expecting a Rugged::Reference, Rugged::Commit or String instance");
}
rugged_exception_check(error);
}
/*
* call-seq:
* branch.move(old_name, new_name, options = {}) -> new_branch
* branch.move(branch, new_name, options = {}) -> new_branch
* branch.rename(old_name, new_name, options = {}) -> new_branch
* branch.rename(branch, new_name, options = {}) -> new_branch
*
* Rename a branch to +new_name+.
*
* +new_name+ needs to be a branch name, not an absolute reference path
* (e.g. +development+ instead of +refs/heads/development+).
*
* The following options can be passed in the +options+ Hash:
*
* :force ::
* Overwrites the branch with the given +name+, if it already exists,
* instead of raising an exception.
*
* If a branch with the given +new_name+ already exists and +:force+ is not +true+,
* an exception will be raised.
*
* A new Rugged::Branch object for the renamed branch will be returned.
*
*/
static VALUE rb_git_branch_collection_move(int argc, VALUE *argv, VALUE self)
{
VALUE rb_repo = rugged_owner(self), rb_name_or_branch, rb_new_branch_name, rb_options;
git_reference *old_branch = NULL, *new_branch = NULL;
git_repository *repo;
int error, force = 0;
rb_scan_args(argc, argv, "20:", &rb_name_or_branch, &rb_new_branch_name, &rb_options);
Check_Type(rb_new_branch_name, T_STRING);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = rugged_branch_lookup(&old_branch, repo, rb_name_or_branch);
rugged_exception_check(error);
if (!NIL_P(rb_options)) {
force = RTEST(rb_hash_aref(rb_options, CSTR2SYM("force")));
}
error = git_branch_move(&new_branch, old_branch, StringValueCStr(rb_new_branch_name), force);
git_reference_free(old_branch);
rugged_exception_check(error);
return rugged_branch_new(rugged_owner(self), new_branch);
}
/*
* call-seq:
* Tree::Builder.new(repository, [tree])
*
* Create a new Rugged::Tree::Builder instance to write a tree to
* the given +repository+.
*
* If an optional +tree+ is given, the returned Tree::Builder will be
* initialized with the entry of +tree+. Otherwise, the Tree::Builder
* will be empty and has to be filled manually.
*/
static VALUE rb_git_treebuilder_new(int argc, VALUE *argv, VALUE klass)
{
git_treebuilder *builder;
git_repository *repo;
git_tree *tree = NULL;
VALUE rb_object, rb_builder, rb_repo;
int error;
if (rb_scan_args(argc, argv, "11", &rb_repo, &rb_object) == 2) {
if (!rb_obj_is_kind_of(rb_object, rb_cRuggedTree))
rb_raise(rb_eTypeError, "A Rugged::Tree instance is required");
Data_Get_Struct(rb_object, git_tree, tree);
}
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_treebuilder_new(&builder, repo, tree);
rugged_exception_check(error);
rb_builder = Data_Wrap_Struct(klass, NULL, &rb_git_treebuilder_free, builder);
rugged_set_owner(rb_builder, rb_repo);
return rb_builder;
}
/*
* call-seq:
* commit.to_mbox(options = {}) -> str
*
* Returns +commit+'s contents formatted to resemble UNIX mailbox format.
*
* Does not (yet) support merge commits.
*
* The following options can be passed in the +options+ Hash:
*
* :patch_no ::
* Number for this patch in the series. Defaults to +1+.
*
* :total_patches ::
* Total number of patches in the series. Defaults to +1+.
*
* :exclude_subject_patch_marker ::
* If set to true, no "[PATCH]" marker will be
* added to the beginning of the subject line.
*
* Additionally, you can also pass the same options as for Rugged::Tree#diff.
*/
static VALUE rb_git_commit_to_mbox(int argc, VALUE *argv, VALUE self)
{
git_buf email_patch = { NULL };
git_repository *repo;
git_commit *commit;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
git_diff_format_email_flags_t flags = GIT_DIFF_FORMAT_EMAIL_NONE;
VALUE rb_repo = rugged_owner(self), rb_email_patch = Qnil, rb_val, rb_options;
int error;
size_t patch_no = 1, total_patches = 1;
rb_scan_args(argc, argv, ":", &rb_options);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Data_Get_Struct(self, git_commit, commit);
if (!NIL_P(rb_options)) {
Check_Type(rb_options, T_HASH);
rb_val = rb_hash_aref(rb_options, CSTR2SYM("patch_no"));
if (!NIL_P(rb_val))
patch_no = NUM2INT(rb_val);
rb_val = rb_hash_aref(rb_options, CSTR2SYM("total_patches"));
if (!NIL_P(rb_val))
total_patches = NUM2INT(rb_val);
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_subject_patch_marker"))))
flags |= GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER;
rugged_parse_diff_options(&opts, rb_options);
}
error = git_diff_commit_as_email(
&email_patch,
repo,
commit,
patch_no,
total_patches,
flags,
&opts);
if (error) goto cleanup;
rb_email_patch = rb_enc_str_new(email_patch.ptr, email_patch.size, rb_utf8_encoding());
cleanup:
xfree(opts.pathspec.strings);
git_buf_free(&email_patch);
rugged_exception_check(error);
return rb_email_patch;
}
/*
* 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:
* tags.create(name, target[, force = false][, annotation = nil]) -> oid
*
* Create a new tag with the specified +name+ on +target+ in +repo+.
*
* If +annotation+ is not +nil+, it will cause the creation of an annotated tag object.
* +annotation+ has to contain the following key value pairs:
*
* :tagger ::
* An optional Hash containing a git signature. Defaults to the signature
* from the configuration if only `:message` is given. Will cause the
* creation of an annotated tag object if present.
*
* :message ::
* An optional string containing the message for the new tag.
*
* Returns the OID of the newly created tag.
*/
static VALUE rb_git_tag_collection_create(int argc, VALUE *argv, VALUE self)
{
git_oid tag_oid;
git_repository *repo = NULL;
git_object *target = NULL;
int error, force = 0;
VALUE rb_repo = rugged_owner(self), rb_name, rb_target, rb_force, rb_annotation;
rb_scan_args(argc, argv, "21:", &rb_name, &rb_target, &rb_force, &rb_annotation);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Check_Type(rb_name, T_STRING);
if (!NIL_P(rb_force))
force = rugged_parse_bool(rb_force);
target = rugged_object_get(repo, rb_target, GIT_OBJ_ANY);
if (NIL_P(rb_annotation)) {
error = git_tag_create_lightweight(
&tag_oid,
repo,
StringValueCStr(rb_name),
target,
force
);
} else {
git_signature *tagger = rugged_signature_get(
rb_hash_aref(rb_annotation, CSTR2SYM("tagger")), repo
);
VALUE rb_message = rb_hash_aref(rb_annotation, CSTR2SYM("message"));
Check_Type(rb_message, T_STRING);
error = git_tag_create(
&tag_oid,
repo,
StringValueCStr(rb_name),
target,
tagger,
StringValueCStr(rb_message),
force
);
git_signature_free(tagger);
}
git_object_free(target);
rugged_exception_check(error);
return rb_git_tag_collection_aref(self, rb_name);
}
static VALUE rb_git_merge_file(int argc, VALUE *argv, VALUE self)
{
VALUE rb_path, rb_options;
VALUE rb_result = rb_hash_new();
VALUE rb_repo = rugged_owner(self);
git_repository *repo;
git_index *index;
const git_index_entry *ancestor, *ours, *theirs;
git_merge_file_result merge_file_result = {0};
git_merge_file_options opts = GIT_MERGE_FILE_OPTIONS_INIT;
int error;
rb_scan_args(argc, argv, "1:", &rb_path, &rb_options);
if (!NIL_P(rb_options)) {
Check_Type(rb_options, T_HASH);
rugged_parse_merge_file_options(&opts, rb_options);
}
Check_Type(rb_path, T_STRING);
Data_Get_Struct(self, git_index, index);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_index_conflict_get(&ancestor, &ours, &theirs, index, StringValueCStr(rb_path));
if (error == GIT_ENOTFOUND)
return Qnil;
else
rugged_exception_check(error);
if (ours == NULL)
rb_raise(rb_eRuntimeError, "The conflict does not have a stage 2 entry");
else if (theirs == NULL)
rb_raise(rb_eRuntimeError, "The conflict does not have a stage 3 entry");
error = git_merge_file_from_index(&merge_file_result, repo, ancestor, ours, theirs, &opts);
rugged_exception_check(error);
rb_hash_aset(rb_result, CSTR2SYM("automergeable"), merge_file_result.automergeable ? Qtrue : Qfalse);
rb_hash_aset(rb_result, CSTR2SYM("path"), rb_path);
rb_hash_aset(rb_result, CSTR2SYM("filemode"), INT2FIX(merge_file_result.mode));
rb_hash_aset(rb_result, CSTR2SYM("data"), rb_str_new(merge_file_result.ptr, merge_file_result.len));
git_merge_file_result_free(&merge_file_result);
return rb_result;
}
/*
* call-seq:
* tags.delete(name) -> nil
*
* Delete the tag reference identified by +name+.
*/
static VALUE rb_git_tag_collection_delete(VALUE self, VALUE rb_name)
{
VALUE rb_repo = rugged_owner(self);
git_repository *repo;
int error;
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Check_Type(rb_name, T_STRING);
error = git_tag_delete(repo, StringValueCStr(rb_name));
rugged_exception_check(error);
return Qnil;
}
/*
* call-seq:
* Blob.from_buffer(repository, bytes) -> oid
*
* Write a blob to +repository+ with the contents specified
* in +buffer+. In Ruby 1.9.x, the encoding of +buffer+ is
* ignored and bytes are copied as-is.
*/
static VALUE rb_git_blob_from_buffer(VALUE self, VALUE rb_repo, VALUE rb_buffer)
{
int error;
git_oid oid;
git_repository *repo;
Check_Type(rb_buffer, T_STRING);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_blob_create_frombuffer(&oid, repo, RSTRING_PTR(rb_buffer), RSTRING_LEN(rb_buffer));
rugged_exception_check(error);
return rugged_create_oid(&oid);
}
/*
* call-seq:
* Blob.from_disk(repository, file_path) -> oid
*
* Write the file specified in +file_path+ to a blob in +repository+.
* The repository can be bare or not.
*
* Example:
*
* Blob.from_disk(repo, '/var/repos/blob.h') #=> '5b5b025afb0b4c913b4c338a42934a3863bf3643'
*/
static VALUE rb_git_blob_from_disk(VALUE self, VALUE rb_repo, VALUE rb_path)
{
int error;
git_oid oid;
git_repository *repo;
Check_Type(rb_path, T_STRING);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_blob_create_fromdisk(&oid, repo, StringValueCStr(rb_path));
rugged_exception_check(error);
return rugged_create_oid(&oid);
}
static VALUE each_branch(int argc, VALUE *argv, VALUE self, int branch_names_only)
{
VALUE rb_repo = rugged_owner(self), rb_filter;
git_repository *repo;
git_branch_iterator *iter;
int error, exception = 0;
git_branch_t filter = (GIT_BRANCH_LOCAL | GIT_BRANCH_REMOTE), branch_type;
rb_scan_args(argc, argv, "01", &rb_filter);
if (!rb_block_given_p()) {
VALUE symbol = branch_names_only ? CSTR2SYM("each_name") : CSTR2SYM("each");
return rb_funcall(self, rb_intern("to_enum"), 2, symbol, rb_filter);
}
rugged_check_repo(rb_repo);
if (!NIL_P(rb_filter))
filter = parse_branch_type(rb_filter);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_branch_iterator_new(&iter, repo, filter);
rugged_exception_check(error);
if (branch_names_only) {
git_reference *branch;
while (!exception && (error = git_branch_next(&branch, &branch_type, iter)) == GIT_OK) {
rb_protect(rb_yield, rb_str_new_utf8(git_reference_shorthand(branch)), &exception);
}
} else {
git_reference *branch;
while (!exception && (error = git_branch_next(&branch, &branch_type, iter)) == GIT_OK) {
rb_protect(rb_yield, rugged_branch_new(rb_repo, branch), &exception);
}
}
git_branch_iterator_free(iter);
if (exception)
rb_jump_tag(exception);
if (error != GIT_ITEROVER)
rugged_exception_check(error);
return Qnil;
}
static VALUE rb_git_remote_collection__each(VALUE self, int only_names)
{
git_repository *repo;
git_strarray remotes;
size_t i;
int error = 0;
int exception = 0;
VALUE rb_repo;
if (!rb_block_given_p()) {
if (only_names)
return rb_funcall(self, rb_intern("to_enum"), 1, CSTR2SYM("each_name"));
else
return rb_funcall(self, rb_intern("to_enum"), 1, CSTR2SYM("each"));
}
rb_repo = rugged_owner(self);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_remote_list(&remotes, repo);
rugged_exception_check(error);
if (only_names) {
for (i = 0; !exception && i < remotes.count; ++i) {
rb_protect(rb_yield, rb_str_new_utf8(remotes.strings[i]), &exception);
}
} else {
for (i = 0; !exception && !error && i < remotes.count; ++i) {
git_remote *remote;
if (!(error = git_remote_lookup(&remote, repo, remotes.strings[i])))
rb_protect(rb_yield, rugged_remote_new(rb_repo, remote), &exception);
}
}
git_strarray_free(&remotes);
if (exception)
rb_jump_tag(exception);
rugged_exception_check(error);
return Qnil;
}
static VALUE rb_git_remote_names(VALUE klass, VALUE rb_repo)
{
git_repository *repo;
git_strarray remotes;
VALUE rb_remote_names;
int error;
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_remote_list(&remotes, repo);
rugged_exception_check(error);
rb_remote_names = rugged_strarray_to_rb_ary(&remotes);
git_strarray_free(&remotes);
return rb_remote_names;
}
/* * 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; }
static VALUE each_tag(int argc, VALUE *argv, VALUE self, int tag_names_only)
{
git_repository *repo;
git_strarray tags;
size_t i;
int error, exception = 0;
VALUE rb_repo = rugged_owner(self), rb_pattern;
const char *pattern = NULL;
rb_scan_args(argc, argv, "01", &rb_pattern);
if (!rb_block_given_p()) {
VALUE symbol = tag_names_only ? CSTR2SYM("each_name") : CSTR2SYM("each");
return rb_funcall(self, rb_intern("to_enum"), 2, symbol, rb_pattern);
}
if (!NIL_P(rb_pattern)) {
Check_Type(rb_pattern, T_STRING);
pattern = StringValueCStr(rb_pattern);
}
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_tag_list_match(&tags, pattern ? pattern : "", repo);
rugged_exception_check(error);
if (tag_names_only) {
for (i = 0; !exception && i < tags.count; ++i)
rb_protect(rb_yield, rb_str_new_utf8(tags.strings[i]), &exception);
} else {
for (i = 0; !exception && i < tags.count; ++i) {
rb_protect(rb_yield, rb_git_tag_collection_aref(self,
rb_str_new_utf8(tags.strings[i])), &exception);
}
}
git_strarray_free(&tags);
if (exception)
rb_jump_tag(exception);
return Qnil;
}
/*
* call-seq:
* Remote.lookup(repository, name) -> remote or nil
*
* Return an existing remote with +name+ in +repository+:
* - +name+: a valid remote name
*
* Returns a new Rugged::Remote object or +nil+ if the
* remote doesn't exist
*
* Rugged::Remote.lookup(@repo, 'origin') #=> #<Rugged::Remote:0x00000001fbfa80>
*/
static VALUE rb_git_remote_lookup(VALUE klass, VALUE rb_repo, VALUE rb_name)
{
git_remote *remote;
git_repository *repo;
int error;
Check_Type(rb_name, T_STRING);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_remote_load(&remote, repo, StringValueCStr(rb_name));
if (error == GIT_ENOTFOUND)
return Qnil;
rugged_exception_check(error);
return rugged_remote_new(klass, rb_repo, remote);
}
/*
* call-seq:
* tags.create_annotation(name, target, annotation) -> annotation
*
* Create a new annotated tag object with the specified +name+ on +target+ in
* +repo+.
*
* Unlike the +create+ method, +create_annotation+ simply creates a tag
* object. It does not write a tag ref.
*
* +annotation+ must have the following keys:
*
* :tagger ::
* An optional Hash containing a git signature. Defaults to the signature
* from the configuration if only `:message` is given. Will cause the
* creation of an annotated tag object if present.
*
* :message ::
* An optional string containing the message for the new tag.
*
* Returns an instance of Rugged::Tag::Annotation representing the newly
* created annotation.
*/
static VALUE rb_git_tag_collection_create_annotation(VALUE self, VALUE rb_name, VALUE rb_target, VALUE rb_annotation)
{
git_oid tag_oid;
git_repository *repo = NULL;
git_object *target = NULL, *tag = NULL;
git_signature *tagger = NULL;
VALUE rb_message;
int error;
VALUE rb_repo = rugged_owner(self);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Check_Type(rb_name, T_STRING);
target = rugged_object_get(repo, rb_target, GIT_OBJ_ANY);
rb_message = rb_hash_aref(rb_annotation, CSTR2SYM("message"));
Check_Type(rb_message, T_STRING);
tagger = rugged_signature_get(
rb_hash_aref(rb_annotation, CSTR2SYM("tagger")), repo
);
error = git_tag_annotation_create(
&tag_oid,
repo,
StringValueCStr(rb_name),
target,
tagger,
StringValueCStr(rb_message)
);
git_object_free(target);
git_signature_free(tagger);
rugged_exception_check(error);
error = git_object_lookup(&tag, repo, &tag_oid, GIT_OBJ_TAG);
rugged_exception_check(error);
return rugged_object_new(rb_repo, tag);
}
static VALUE rb_git_merge_file(int argc, VALUE *argv, VALUE self)
{
VALUE rb_path, rb_options, rb_result;
VALUE rb_repo = rugged_owner(self);
git_repository *repo;
git_index *index;
const git_index_entry *ancestor, *ours, *theirs;
git_merge_file_result merge_file_result = {0};
git_merge_file_options opts = GIT_MERGE_FILE_OPTIONS_INIT;
int error;
rb_scan_args(argc, argv, "1:", &rb_path, &rb_options);
if (!NIL_P(rb_options))
rugged_parse_merge_file_options(&opts, rb_options);
Check_Type(rb_path, T_STRING);
Data_Get_Struct(self, git_index, index);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_index_conflict_get(&ancestor, &ours, &theirs, index, StringValueCStr(rb_path));
if (error == GIT_ENOTFOUND)
return Qnil;
else
rugged_exception_check(error);
if (ours == NULL)
rb_raise(rb_eRuntimeError, "The conflict does not have a stage 2 entry");
else if (theirs == NULL)
rb_raise(rb_eRuntimeError, "The conflict does not have a stage 3 entry");
error = git_merge_file_from_index(&merge_file_result, repo, ancestor, ours, theirs, &opts);
rugged_exception_check(error);
rb_result = rb_merge_file_result_fromC(&merge_file_result);
git_merge_file_result_free(&merge_file_result);
return rb_result;
}
/*
* call-seq:
* branches[name] -> branch
*
* Return the branch with the given +name+.
*
* Branches can be looked up by their relative (+development+) or absolute
* (+refs/heads/development+) branch name.
*
* If a local branch and a remote branch both share the same short name
* (e.g. +refs/heads/origin/master+ and +refs/remotes/origin/master+),
* passing +origin/master+ as the +name+ will return the local branch.
* You can explicitly request the local branch by passing
* +heads/origin/master+, or the remote branch through +remotes/origin/master+.
*
* Returns the looked up branch, or +nil+ if the branch doesn't exist.
*/
static VALUE rb_git_branch_collection_aref(VALUE self, VALUE rb_name) {
git_reference *branch;
git_repository *repo;
VALUE rb_repo = rugged_owner(self);
int error;
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Check_Type(rb_name, T_STRING);
error = rugged_branch_lookup(&branch, repo, rb_name);
if (error == GIT_ENOTFOUND)
return Qnil;
rugged_exception_check(error);
return rugged_branch_new(rb_repo, branch);
}
/*
* call-seq:
* remotes.delete(remote) -> nil
* remotes.delete(name) -> nil
*
* Delete the specified remote.
*
* repo.remotes.delete("origin")
* # Remote no longer exists in the configuration.
*/
static VALUE rb_git_remote_collection_delete(VALUE self, VALUE rb_name_or_remote)
{
VALUE rb_repo = rugged_owner(self);
git_repository *repo;
int error;
if (rb_obj_is_kind_of(rb_name_or_remote, rb_cRuggedRemote))
rb_name_or_remote = rb_funcall(rb_name_or_remote, rb_intern("name"), 0);
if (TYPE(rb_name_or_remote) != T_STRING)
rb_raise(rb_eTypeError, "Expecting a String or Rugged::Remote instance");
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_remote_delete(repo, StringValueCStr(rb_name_or_remote));
rugged_exception_check(error);
return Qnil;
}
/*
* call-seq:
* branches.delete(branch) -> nil
* branches.delete(name) -> nil
*
* Delete the specified branch.
*
* If a Rugged::Branch object was passed, the object will become
* invalidated and won't be able to be used for any other operations.
*/
static VALUE rb_git_branch_collection_delete(VALUE self, VALUE rb_name_or_branch)
{
git_reference *branch;
git_repository *repo;
VALUE rb_repo = rugged_owner(self);
int error;
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = rugged_branch_lookup(&branch, repo, rb_name_or_branch);
rugged_exception_check(error);
error = git_branch_delete(branch);
git_reference_free(branch);
rugged_exception_check(error);
return Qnil;
}
/*
* call-seq:
* Remote.new(repository, url) -> remote
*
* Return a new remote with +url+ in +repository+ , the remote is not persisted:
* - +url+: a valid remote url
*
* Returns a new Rugged::Remote object
*
* Rugged::Remote.new(@repo, 'git://github.com/libgit2/libgit2.git') #=> #<Rugged::Remote:0x00000001fbfa80>
*/
static VALUE rb_git_remote_new(VALUE klass, VALUE rb_repo, VALUE rb_url)
{
git_remote *remote;
git_repository *repo;
int error;
rugged_check_repo(rb_repo);
rugged_validate_remote_url(rb_url);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_remote_create_anonymous(
&remote,
repo,
StringValueCStr(rb_url),
NULL);
rugged_exception_check(error);
return rugged_remote_new(klass, rb_repo, remote);
}
/*
* call-seq:
* remotes[name] -> remote or nil
*
* Lookup a remote in the collection with the given +name+.
*
* Returns a new Rugged::Remote object or +nil+ if the
* remote doesn't exist.
*
* @repo.remotes["origin"] #=> #<Rugged::Remote:0x00000001fbfa80>
*/
static VALUE rb_git_remote_collection_aref(VALUE self, VALUE rb_name)
{
git_remote *remote;
git_repository *repo;
int error;
VALUE rb_repo = rugged_owner(self);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Check_Type(rb_name, T_STRING);
error = git_remote_lookup(&remote, repo, StringValueCStr(rb_name));
if (error == GIT_ENOTFOUND)
return Qnil;
rugged_exception_check(error);
return rugged_remote_new(rb_repo, remote);
}
/*
* 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:
* Remote.add(repository, name, url) -> remote
*
* Add a new remote with +name+ and +url+ to +repository+
* - +url+: a valid remote url
* - +name+: a valid remote name
*
* Returns a new Rugged::Remote object
*
* Rugged::Remote.add(@repo, 'origin', 'git://github.com/libgit2/rugged.git') #=> #<Rugged::Remote:0x00000001fbfa80>
*/
static VALUE rb_git_remote_add(VALUE klass, VALUE rb_repo,VALUE rb_name, VALUE rb_url)
{
git_remote *remote;
git_repository *repo;
int error;
Check_Type(rb_name, T_STRING);
rugged_validate_remote_url(rb_url);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_remote_create(
&remote,
repo,
StringValueCStr(rb_name),
StringValueCStr(rb_url));
rugged_exception_check(error);
return rugged_remote_new(klass, rb_repo, remote);
}