static int push_update_reference_cb(const char *refname, const char *status, void *data) {
struct rugged_remote_cb_payload *payload = data;
if (status != NULL)
rb_hash_aset(payload->result, rb_str_new_utf8(refname), rb_str_new_utf8(status));
return GIT_OK;
}
static int push_status_cb(const char *ref, const char *msg, void *payload)
{
VALUE rb_result_hash = (VALUE)payload;
if (msg != NULL)
rb_hash_aset(rb_result_hash, rb_str_new_utf8(ref), rb_str_new_utf8(msg));
return GIT_OK;
}
/*
* call-seq:
* annotation.name -> name
*
* Return a string with the name of this tag +annotation+.
*
* annotation.name #=> "v0.16.0"
*/
static VALUE rb_git_tag_annotation_name(VALUE self)
{
git_tag *tag;
Data_Get_Struct(self, git_tag, tag);
return rb_str_new_utf8(git_tag_name(tag));
}
static VALUE rb_git_indexentry_fromC(const git_index_entry *entry)
{
VALUE rb_entry, rb_mtime, rb_ctime;
unsigned int valid, stage;
if (!entry)
return Qnil;
rb_entry = rb_hash_new();
rb_hash_aset(rb_entry, CSTR2SYM("path"), rb_str_new_utf8(entry->path));
rb_hash_aset(rb_entry, CSTR2SYM("oid"), rugged_create_oid(&entry->id));
rb_hash_aset(rb_entry, CSTR2SYM("dev"), INT2FIX(entry->dev));
rb_hash_aset(rb_entry, CSTR2SYM("ino"), INT2FIX(entry->ino));
rb_hash_aset(rb_entry, CSTR2SYM("mode"), INT2FIX(entry->mode));
rb_hash_aset(rb_entry, CSTR2SYM("gid"), INT2FIX(entry->gid));
rb_hash_aset(rb_entry, CSTR2SYM("uid"), INT2FIX(entry->uid));
rb_hash_aset(rb_entry, CSTR2SYM("file_size"), INT2FIX(entry->file_size));
valid = (entry->flags & GIT_IDXENTRY_VALID);
rb_hash_aset(rb_entry, CSTR2SYM("valid"), valid ? Qtrue : Qfalse);
stage = (entry->flags & GIT_IDXENTRY_STAGEMASK) >> GIT_IDXENTRY_STAGESHIFT;
rb_hash_aset(rb_entry, CSTR2SYM("stage"), INT2FIX(stage));
rb_mtime = rb_time_new(entry->mtime.seconds, entry->mtime.nanoseconds / 1000);
rb_ctime = rb_time_new(entry->ctime.seconds, entry->ctime.nanoseconds / 1000);
rb_hash_aset(rb_entry, CSTR2SYM("ctime"), rb_ctime);
rb_hash_aset(rb_entry, CSTR2SYM("mtime"), rb_mtime);
return rb_entry;
}
/*
* call-seq:
* Rebase.next() -> operation or nil
*
* Perform the next step in the rebase. The returned operation is a
* Hash with its details or nil if there are no more operations to
* perform. The Hash contains some of the following entries:
*
* :type ::
* The type of operation being done. Can be one of +:pick+,
* +:reword+, +:edit+, +:squash+, +:fixup+ or +:exec+.
*
* :id ::
* The id of the commit being cherry-picked. Exists for all but
* +:exec+ operations.
*
* :exec ::
* If the operatin is +:exec+ this is what the user asked to be
* executed.
*/
static VALUE rb_git_rebase_next(VALUE self)
{
int error;
git_rebase *rebase;
git_rebase_operation *operation;
VALUE hash, val;
Data_Get_Struct(self, git_rebase, rebase);
error = git_rebase_next(&operation, rebase);
if (error == GIT_ITEROVER)
return Qnil;
rugged_exception_check(error);
/* Create the operation hash out of the relevant details */
hash = rb_hash_new();
val = rebase_operation_type(operation);
rb_hash_aset(hash, CSTR2SYM("type"), val);
if (operation->type != GIT_REBASE_OPERATION_EXEC) {
val = rugged_create_oid(&operation->id);
rb_hash_aset(hash, CSTR2SYM("id"), val);
}
if (operation->exec) {
val = rb_str_new_utf8(operation->exec);
rb_hash_aset(hash, CSTR2SYM("exec"), val);
}
return hash;
}
/*
* 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));
}
/*
* call-seq:
* ref.peel -> oid
*
* Peels tag objects to the sha that they point at. Replicates
* +git show-ref --dereference+.
*/
static VALUE rb_git_ref_peel(VALUE self)
{
/* Leave room for \0 */
git_reference *ref;
git_object *object;
char oid[GIT_OID_HEXSZ + 1];
int error;
Data_Get_Struct(self, git_reference, ref);
error = git_reference_peel(&object, ref, GIT_OBJ_ANY);
if (error == GIT_ENOTFOUND)
return Qnil;
else
rugged_exception_check(error);
if (git_reference_type(ref) == GIT_REF_OID &&
!git_oid_cmp(git_object_id(object), git_reference_target(ref))) {
git_object_free(object);
return Qnil;
} else {
git_oid_tostr(oid, sizeof(oid), git_object_id(object));
git_object_free(object);
return rb_str_new_utf8(oid);
}
}
static VALUE reflog_entry_new(const git_reflog_entry *entry)
{
VALUE rb_entry = rb_hash_new();
const char *message;
rb_hash_aset(rb_entry,
CSTR2SYM("id_old"),
rugged_create_oid(git_reflog_entry_id_old(entry))
);
rb_hash_aset(rb_entry,
CSTR2SYM("id_new"),
rugged_create_oid(git_reflog_entry_id_new(entry))
);
rb_hash_aset(rb_entry,
CSTR2SYM("committer"),
rugged_signature_new(git_reflog_entry_committer(entry), NULL)
);
if ((message = git_reflog_entry_message(entry)) != NULL) {
rb_hash_aset(rb_entry, CSTR2SYM("message"), rb_str_new_utf8(message));
}
return rb_entry;
}
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:
* commit.header -> str
*
* Returns +commit+'s entire raw header.
*/
static VALUE rb_git_commit_header(VALUE self)
{
git_commit *commit;
const char *raw_header;
Data_Get_Struct(self, git_commit, commit);
raw_header = git_commit_raw_header(commit);
return rb_str_new_utf8(raw_header);
}
/*
* 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;
}
/*
* call-seq:
* remote.push_url() -> string or nil
*
* Returns the remote's url for pushing or nil if no special url for
* pushing is set.
* remote.push_url #=> "git://github.com/libgit2/rugged.git"
*/
static VALUE rb_git_remote_push_url(VALUE self)
{
git_remote *remote;
const char * push_url;
Data_Get_Struct(self, git_remote, remote);
push_url = git_remote_pushurl(remote);
return push_url ? rb_str_new_utf8(push_url) : Qnil;
}
/*
* call-seq:
* branch.name -> string
*
* Returns the name of +branch+.
*
* See Rugged::Reference#canonical_name if you need the fully qualified
* name of the underlying reference.
*/
static VALUE rb_git_branch_name(VALUE self)
{
git_reference *branch;
const char *branch_name;
Data_Get_Struct(self, git_reference, branch);
rugged_exception_check(git_branch_name(&branch_name, branch));
return rb_str_new_utf8(branch_name);
}
/*
* call-seq:
* reference.target_id -> id
* reference.target_id -> ref_name
*
* Return the target identifier of +reference+.
*
* If +reference+ is a symbolic reference, it returns the canonical
* name of the target reference.
*
* If +reference+ is a direct reference, it returns the sha id of the target.
*
* ref1.type #=> :symbolic
* ref1.target_id #=> "refs/heads/master"
*
* ref2.type #=> :direct
* ref2.target_id #=> "de5ba987198bcf2518885f0fc1350e5172cded78"
*/
static VALUE rb_git_ref_target_id(VALUE self)
{
git_reference *ref;
Data_Get_Struct(self, git_reference, ref);
if (git_reference_type(ref) == GIT_REF_OID) {
return rugged_create_oid(git_reference_target(ref));
} else {
return rb_str_new_utf8(git_reference_symbolic_target(ref));
}
}
VALUE rugged_strarray_to_rb_ary(git_strarray *str_array)
{
VALUE rb_array = rb_ary_new2(str_array->count);
size_t i;
for (i = 0; i < str_array->count; ++i) {
rb_ary_push(rb_array, rb_str_new_utf8(str_array->strings[i]));
}
return rb_array;
}
static VALUE rugged_git_note_message(const git_note *note)
{
const char *message;
message = git_note_message(note);
/*
* assume the note message is utf8 compatible, because that's
* the sensible thing to do.
*/
return rb_str_new_utf8(message);
}
static VALUE rugged_rhead_new(const git_remote_head *head)
{
VALUE rb_head = rb_hash_new();
rb_hash_aset(rb_head, CSTR2SYM("local?"), head->local ? Qtrue : Qfalse);
rb_hash_aset(rb_head, CSTR2SYM("oid"), rugged_create_oid(&head->oid));
rb_hash_aset(rb_head, CSTR2SYM("loid"),
git_oid_iszero(&head->loid) ? Qnil : rugged_create_oid(&head->loid));
rb_hash_aset(rb_head, CSTR2SYM("name"), rb_str_new_utf8(head->name));
return rb_head;
}
/*
* call-seq:
* repo.notes_default_ref() -> string
*
* Get the default notes reference for a +repository+:
*
* Returns a new String object.
*
* repo.default_notes_ref #=> "refs/notes/commits"
*/
static VALUE rb_git_note_default_ref_GET(VALUE self)
{
git_repository *repo = NULL;
const char * ref_name;
Data_Get_Struct(self, git_repository, repo);
rugged_exception_check(
git_note_default_ref(&ref_name, repo)
);
return rb_str_new_utf8(ref_name);
}
/*
* call-seq:
* annotation.message -> msg
*
* Return the message of this tag +annotation+. This includes the full body of the
* message and any optional footers or signatures after it.
*
* annotation.message #=> "Release v0.16.0, codename 'broken stuff'"
*/
static VALUE rb_git_tag_annotation_message(VALUE self)
{
git_tag *tag;
const char *message;
Data_Get_Struct(self, git_tag, tag);
message = git_tag_message(tag);
if (!message)
return Qnil;
return rb_str_new_utf8(message);
}
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 int update_tips_cb(const char *refname, const git_oid *src, const git_oid *dest, void *data)
{
struct rugged_remote_cb_payload *payload = data;
VALUE args = rb_ary_new2(4);
if (NIL_P(payload->update_tips))
return 0;
rb_ary_push(args, payload->update_tips);
rb_ary_push(args, rb_str_new_utf8(refname));
rb_ary_push(args, git_oid_iszero(src) ? Qnil : rugged_create_oid(src));
rb_ary_push(args, git_oid_iszero(dest) ? Qnil : rugged_create_oid(dest));
rb_protect(rugged__block_yield_splat, args, &payload->exception);
return payload->exception ? GIT_ERROR : GIT_OK;
}
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 int certificate_check_cb(git_cert *cert, int valid, const char *host, void *data)
{
struct rugged_remote_cb_payload *payload = data;
VALUE args = rb_ary_new2(3);
VALUE ret;
if (NIL_P(payload->certificate_check))
return valid ? 0 : GIT_ECERTIFICATE;
rb_ary_push(args, payload->certificate_check);
rb_ary_push(args, valid ? Qtrue : Qfalse);
rb_ary_push(args, rb_str_new_utf8(host));
ret = rb_protect(rugged__block_yield_splat, args, &payload->exception);
if (payload->exception)
return GIT_ERROR;
return rugged_parse_bool(ret) ? GIT_OK : GIT_ECERTIFICATE;
}
static int rugged__treewalk_cb(const char *root, const git_tree_entry *entry, void *payload)
{
int *exception = (int *)payload;
VALUE rb_result, rb_args = rb_ary_new2(2);
rb_ary_push(rb_args, rb_str_new_utf8(root));
rb_ary_push(rb_args, rb_git_treeentry_fromC(entry));
rb_result = rb_protect(rb_yield_splat, rb_args, exception);
if (*exception)
return -1;
/* skip entry when 'false' is returned */
if (TYPE(rb_result) == T_FALSE)
return 1;
/* otherwise continue normal iteration */
return 0;
}
/*
* call-seq:
* Commit.create_to_s(repository, data = {}) -> str
*
* Create a string with the contents of the commit, created with the
* given +data+ arguments, passed as a +Hash+:
*
* - +:message+: a string with the full text for the commit's message
* - +:committer+ (optional): a hash with the signature for the committer,
* defaults to the signature from the configuration
* - +:author+ (optional): a hash with the signature for the author,
* defaults to the signature from the configuration
* - +:parents+: an +Array+ with zero or more parents for this commit,
* represented as <tt>Rugged::Commit</tt> instances, or OID +String+.
* - +:tree+: the tree for this commit, represented as a <tt>Rugged::Tree</tt>
* instance or an OID +String+.
*
* author = {:email=>"*****@*****.**", :time=>Time.now, :name=>"Vicent Mart\303\255"}
*
* Rugged::Commit.create(r,
* :author => author,
* :message => "Hello world\n\n",
* :committer => author,
* :parents => ["2cb831a8aea28b2c1b9c63385585b864e4d3bad1"],
* :tree => some_tree) #=> "tree some_tree\nparent 2cb831...."
*/
static VALUE rb_git_commit_create_to_s(VALUE self, VALUE rb_repo, VALUE rb_data)
{
int error = 0;
struct commit_data commit_data = { Qnil };
git_repository *repo;
git_buf buf = { 0 };
VALUE ret;
Check_Type(rb_data, T_HASH);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
if ((error = parse_commit_options(&commit_data, repo, rb_data)) < 0)
goto cleanup;
error = git_commit_create_buffer(
&buf,
repo,
commit_data.author,
commit_data.committer,
NULL,
commit_data.message,
commit_data.tree,
commit_data.parent_count,
commit_data.parents);
cleanup:
free_commit_options(&commit_data);
if (!NIL_P(commit_data.rb_err_obj))
rb_exc_raise(commit_data.rb_err_obj);
rugged_exception_check(error);
ret = rb_str_new_utf8(buf.ptr);
git_buf_free(&buf);
return ret;
}
/*
* call-seq:
* remotes.rename(remote, new_name) { |str| } -> remote
* remotes.rename(name, new_name) { |str| } -> remote
*
* Renames a remote.
*
* All remote-tracking branches and configuration settings
* for the remote are updated.
*
* Non-default refspecs cannot be renamed automatically and will be
* yielded to the given block.
*
* Anonymous, in-memory remotes created through
* +ReferenceCollection#create_anonymous+ can not be given a name through
* this method.
*
* Returns a new Rugged::Remote object with the new name.
*/
static VALUE rb_git_remote_collection_rename(VALUE self, VALUE rb_name_or_remote, VALUE rb_new_name)
{
VALUE rb_repo = rugged_owner(self);
git_repository *repo;
size_t i;
int error, exception;
git_strarray problems;
if (!rb_block_given_p())
rb_raise(rb_eArgError, "Rugged::RemoteCollection#rename must be called with a block");
Check_Type(rb_new_name, T_STRING);
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_rename(&problems, repo, StringValueCStr(rb_name_or_remote), StringValueCStr(rb_new_name));
rugged_exception_check(error);
for (i = exception = 0; !exception && i < problems.count; ++i) {
rb_protect(rb_yield, rb_str_new_utf8(problems.strings[i]), &exception);
}
git_strarray_free(&problems);
if (exception)
rb_jump_tag(exception);
return rb_git_remote_collection_aref(self, rb_new_name);
}
static VALUE rb_git_treeentry_fromC(const git_tree_entry *entry)
{
VALUE rb_entry;
VALUE type;
if (!entry)
return Qnil;
rb_entry = rb_hash_new();
rb_hash_aset(rb_entry, CSTR2SYM("name"), rb_str_new_utf8(git_tree_entry_name(entry)));
rb_hash_aset(rb_entry, CSTR2SYM("oid"), rugged_create_oid(git_tree_entry_id(entry)));
rb_hash_aset(rb_entry, CSTR2SYM("filemode"), INT2FIX(git_tree_entry_filemode(entry)));
switch(git_tree_entry_type(entry)) {
case GIT_OBJ_TREE:
type = CSTR2SYM("tree");
break;
case GIT_OBJ_BLOB:
type = CSTR2SYM("blob");
break;
case GIT_OBJ_COMMIT:
type = CSTR2SYM("commit");
break;
default:
type = Qnil;
break;
}
rb_hash_aset(rb_entry, CSTR2SYM("type"), type);
return rb_entry;
}
static int cb_remote__rename_problem(const char* refspec_name, void *payload)
{
rb_ary_push((VALUE) payload, rb_str_new_utf8(refspec_name));
return 0;
}
/*
* call-seq:
* reference.name -> name
* reference.canonical_name -> name
*
* Returns the fully qualified name of the reference.
*
* +name+ gets overwritten in subclasess like Rugged::Branch or Rugged::Tag
* to return "nicer" names for presentational purposes, while +canonical_name+
* is always supposed to return the fully qualified reference path.
*
* reference.name #=> 'HEAD'
*/
static VALUE rb_git_ref_name(VALUE self)
{
git_reference *ref;
Data_Get_Struct(self, git_reference, ref);
return rb_str_new_utf8(git_reference_name(ref));
}
