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)); }