rdavila-rugged 0.24.0b13

data/ext/rugged/rugged_note.c

@@ -0,0 +1,376 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2014 GitHub, Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "rugged.h"
+
+extern VALUE rb_cRuggedRepo;
+extern VALUE rb_cRuggedObject;
+
+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_git_note_oid(const git_note* note)
+{
+	const git_oid *oid;
+	oid = git_note_id(note);
+
+	return rugged_create_oid(oid);
+}
+
+/*
+ *  call-seq:
+ *    obj.notes(notes_ref = 'refs/notes/commits') -> hash
+ *
+ *  Lookup a note for +obj+ from +notes_ref+:
+ *  - +notes_ref+: (optional): canonical name of the reference to use, defaults to "refs/notes/commits"
+ *
+ *  Returns a new Hash object.
+ *
+ *    obj.notes #=> {:message=>"note text\n", :oid=>"94eca2de348d5f672faf56b0decafa5937e3235e"}
+ */
+static VALUE rb_git_note_lookup(int argc, VALUE *argv, VALUE self)
+{
+	git_repository *repo;
+	const char *notes_ref = NULL;
+	VALUE rb_notes_ref;
+	VALUE rb_note_hash;
+	VALUE owner;
+	git_note *note;
+	git_object *object;
+	int error;
+
+	rb_scan_args(argc, argv, "01", &rb_notes_ref);
+
+	if (!NIL_P(rb_notes_ref)) {
+		Check_Type(rb_notes_ref, T_STRING);
+		notes_ref = StringValueCStr(rb_notes_ref);
+	}
+
+	Data_Get_Struct(self, git_object, object);
+
+	owner = rugged_owner(self);
+	Data_Get_Struct(owner, git_repository, repo);
+
+	error = git_note_read(&note, repo, notes_ref, git_object_id(object));
+
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+
+	rugged_exception_check(error);
+
+	rb_note_hash = rb_hash_new();
+	rb_hash_aset(rb_note_hash, CSTR2SYM("message"), rugged_git_note_message(note));
+	rb_hash_aset(rb_note_hash, CSTR2SYM("oid"), rugged_git_note_oid(note));
+
+	git_note_free(note);
+
+	return rb_note_hash;
+}
+
+/*
+ *  call-seq:
+ *    obj.create_note(data = {}) -> oid
+ *
+ *  Write a new +note+ to +object+, with the given +data+
+ *  arguments, passed as a +Hash+:
+ *
+ *  - +:message+: the content of the note to add to the object
+ *  - +: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
+ *  - +:ref+: (optional): canonical name of the reference to use, defaults to "refs/notes/commits"
+ *  - +:force+: (optional): overwrite existing note (disabled by default)
+ *
+ *  When the note is successfully written to disk, its +oid+ will be
+ *  returned as a hex +String+.
+ *
+ *    author = {:email=>"tanoku@gmail.com", :time=>Time.now, :name=>"Vicent Mart\303\255"}
+ *
+ *    obj.create_note(
+ *      :author    => author,
+ *      :committer => author,
+ *      :message   => "Hello world\n\n",
+ *      :ref       => 'refs/notes/builds'
+ *    )
+ */
+static VALUE rb_git_note_create(VALUE self, VALUE rb_data)
+{
+	VALUE rb_ref, rb_message, rb_force;
+	git_repository *repo = NULL;
+	const char *notes_ref = NULL;
+
+	VALUE owner;
+
+	git_signature *author, *committer;
+	git_oid note_oid;
+
+	git_object *target = NULL;
+	int error = 0;
+	int force = 0;
+
+	Check_Type(rb_data, T_HASH);
+
+	Data_Get_Struct(self, git_object, target);
+
+	owner = rugged_owner(self);
+	Data_Get_Struct(owner, git_repository, repo);
+
+	rb_ref = rb_hash_aref(rb_data, CSTR2SYM("ref"));
+
+	rb_force = rb_hash_aref(rb_data, CSTR2SYM("force"));
+	if (!NIL_P(rb_force))
+		force = rugged_parse_bool(rb_force);
+
+	if (!NIL_P(rb_ref)) {
+		Check_Type(rb_ref, T_STRING);
+		notes_ref = StringValueCStr(rb_ref);
+	}
+
+	rb_message = rb_hash_aref(rb_data, CSTR2SYM("message"));
+	Check_Type(rb_message, T_STRING);
+
+	committer = rugged_signature_get(
+		rb_hash_aref(rb_data, CSTR2SYM("committer")), repo
+	);
+
+	author = rugged_signature_get(
+		rb_hash_aref(rb_data, CSTR2SYM("author")), repo
+	);
+
+	error = git_note_create(
+			&note_oid,
+			repo,
+			notes_ref,
+			author,
+			committer,
+			git_object_id(target),
+			StringValueCStr(rb_message),
+			force);
+
+
+	git_signature_free(author);
+	git_signature_free(committer);
+
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&note_oid);
+}
+
+/*
+ *  call-seq:
+ *    obj.remove_note(data = {}) -> boolean
+ *
+ *  Removes a +note+ from +object+, with the given +data+
+ *  arguments, passed as a +Hash+:
+ *
+ *  - +: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
+ *  - +:ref+: (optional): canonical name of the reference to use, defaults to "refs/notes/commits"
+ *
+ *  When the note is successfully removed +true+ will be
+ *  returned as a +Boolean+.
+ *
+ *    author = {:email=>"tanoku@gmail.com", :time=>Time.now, :name=>"Vicent Mart\303\255"}
+ *
+ *    obj.remove_note(
+ *      :author    => author,
+ *      :committer => author,
+ *      :ref       => 'refs/notes/builds'
+ *    )
+ */
+static VALUE rb_git_note_remove(int argc, VALUE *argv, VALUE self)
+{
+	int error = 0;
+	const char *notes_ref = NULL;
+	git_repository *repo = NULL;
+	git_signature *author, *committer;
+	git_object *target = NULL;
+	VALUE rb_data;
+	VALUE rb_ref = Qnil;
+	VALUE rb_author = Qnil;
+	VALUE rb_committer = Qnil;
+	VALUE owner;
+
+	Data_Get_Struct(self, git_object, target);
+
+	owner = rugged_owner(self);
+	Data_Get_Struct(owner, git_repository, repo);
+
+	rb_scan_args(argc, argv, "01", &rb_data);
+
+	if (!NIL_P(rb_data)) {
+		Check_Type(rb_data, T_HASH);
+
+		rb_ref = rb_hash_aref(rb_data, CSTR2SYM("ref"));
+		if (!NIL_P(rb_ref)) {
+			Check_Type(rb_ref, T_STRING);
+			notes_ref = StringValueCStr(rb_ref);
+		}
+
+		rb_committer = rb_hash_aref(rb_data, CSTR2SYM("committer"));
+		rb_author = rb_hash_aref(rb_data, CSTR2SYM("author"));
+	}
+
+	committer = rugged_signature_get(rb_committer, repo);
+	author = rugged_signature_get(rb_author, repo);
+
+	error = git_note_remove(
+			repo,
+			notes_ref,
+			author,
+			committer,
+			git_object_id(target));
+
+	git_signature_free(author);
+	git_signature_free(committer);
+
+	if (error == GIT_ENOTFOUND)
+		return Qfalse;
+
+	rugged_exception_check(error);
+
+	return Qtrue;
+}
+
+static int cb_note__each(const git_oid *blob_id, const git_oid *annotated_object_id, void *data)
+{
+	VALUE rb_args = rb_ary_new2(2);
+	struct rugged_cb_payload *payload = data;
+	git_object *annotated_object;
+	git_object *note_blob;
+
+	git_repository *repo;
+
+	Data_Get_Struct(payload->rb_data, git_repository, repo);
+
+	rugged_exception_check(
+		git_object_lookup(&annotated_object, repo, annotated_object_id, GIT_OBJ_ANY)
+	);
+
+	rugged_exception_check(
+		git_object_lookup(&note_blob, repo, blob_id, GIT_OBJ_BLOB)
+	);
+
+	rb_ary_push(rb_args, rugged_object_new(payload->rb_data, note_blob));
+	rb_ary_push(rb_args, rugged_object_new(payload->rb_data, annotated_object));
+
+	rb_protect(rb_yield_splat, rb_args, &payload->exception);
+
+	return payload->exception ? GIT_ERROR : GIT_OK;
+}
+
+/*
+ *  call-seq:
+ *    repo.each_note(notes_ref = "refs/notes/commits") { |note_blob, annotated_object| block }
+ *    repo.each_note(notes_ref = "refs/notes/commits") -> an_enumerator
+ *
+ *  Call the given block once for each note_blob/annotated_object pair in +repository+
+ *  - +notes_ref+: (optional): canonical name of the reference to use defaults to "refs/notes/commits"
+ *
+ *  If no block is given, an +Enumerator+ is returned.
+ *
+ *    @repo.each_note do |note_blob, annotated_object|
+ *      puts "#{note_blob.oid} => #{annotated_object.oid}"
+ *    end
+ */
+static VALUE rb_git_note_each(int argc, VALUE *argv, VALUE self)
+{
+	git_repository *repo;
+	const char *notes_ref = NULL;
+	int error;
+	struct rugged_cb_payload payload = { self, 0 };
+	VALUE rb_notes_ref;
+
+	rb_scan_args(argc, argv, "01", &rb_notes_ref);
+
+	if (!rb_block_given_p()) {
+		return rb_funcall(self, rb_intern("to_enum"), 3, CSTR2SYM("each_note"), self, rb_notes_ref);
+	}
+
+	if (!NIL_P(rb_notes_ref)) {
+		Check_Type(rb_notes_ref, T_STRING);
+		notes_ref = StringValueCStr(rb_notes_ref);
+	}
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	error = git_note_foreach(repo, notes_ref, &cb_note__each, &payload);
+
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  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;
+	git_buf ref_name = { 0 };
+	VALUE rb_result;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	rugged_exception_check(
+		git_note_default_ref(&ref_name, repo)
+	);
+
+	rb_result = rb_enc_str_new(ref_name.ptr, ref_name.size, rb_utf8_encoding());
+
+	git_buf_free(&ref_name);
+
+	return rb_result;
+}
+
+void Init_rugged_notes(void)
+{
+	rb_define_method(rb_cRuggedObject, "notes", rb_git_note_lookup, -1);
+	rb_define_method(rb_cRuggedObject, "create_note", rb_git_note_create, 1);
+	rb_define_method(rb_cRuggedObject, "remove_note", rb_git_note_remove, -1);
+
+	rb_define_method(rb_cRuggedRepo, "each_note", rb_git_note_each, -1);
+	rb_define_method(rb_cRuggedRepo, "default_notes_ref", rb_git_note_default_ref_GET, 0);
+}

data/ext/rugged/rugged_object.c

@@ -0,0 +1,383 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2014 GitHub, Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "rugged.h"
+
+extern VALUE rb_mRugged;
+extern VALUE rb_cRuggedTagAnnotation;
+extern VALUE rb_cRuggedTree;
+extern VALUE rb_cRuggedCommit;
+extern VALUE rb_cRuggedBlob;
+extern VALUE rb_cRuggedRepo;
+
+VALUE rb_cRuggedObject;
+
+git_otype rugged_otype_get(VALUE self)
+{
+	git_otype type = GIT_OBJ_BAD;
+
+	if (NIL_P(self))
+		return GIT_OBJ_ANY;
+
+	switch (TYPE(self)) {
+	case T_STRING:
+		type = git_object_string2type(StringValueCStr(self));
+		break;
+
+	case T_FIXNUM:
+		type = FIX2INT(self);
+		break;
+
+	case T_SYMBOL: {
+		ID t = SYM2ID(self);
+
+		if (t == rb_intern("commit"))
+			type = GIT_OBJ_COMMIT;
+		else if (t == rb_intern("tree"))
+			type = GIT_OBJ_TREE;
+		else if (t == rb_intern("tag"))
+			type = GIT_OBJ_TAG;
+		else if (t == rb_intern("blob"))
+			type = GIT_OBJ_BLOB;
+	   }
+	}
+
+	if (!git_object_typeisloose(type))
+		rb_raise(rb_eTypeError, "Invalid Git object type specifier");
+
+	return type;
+}
+
+VALUE rugged_otype_new(git_otype t)
+{
+	switch (t) {
+		case GIT_OBJ_COMMIT:
+			return CSTR2SYM("commit");
+		case GIT_OBJ_TAG:
+			return CSTR2SYM("tag");
+		case GIT_OBJ_TREE:
+			return CSTR2SYM("tree");
+		case GIT_OBJ_BLOB:
+			return CSTR2SYM("blob");
+		default:
+			return Qnil;
+	}
+}
+
+int rugged_oid_get(git_oid *oid, git_repository *repo, VALUE p)
+{
+	git_object *object;
+	int error;
+
+	if (rb_obj_is_kind_of(p, rb_cRuggedObject)) {
+		Data_Get_Struct(p, git_object, object);
+		git_oid_cpy(oid, git_object_id(object));
+	} else {
+		Check_Type(p, T_STRING);
+
+		/* Fast path: see if the 40-char string is an OID */
+		if (RSTRING_LEN(p) == 40 &&
+			git_oid_fromstr(oid, RSTRING_PTR(p)) == 0)
+			return GIT_OK;
+
+		if ((error = git_revparse_single(&object, repo, StringValueCStr(p))))
+			return error;
+
+		git_oid_cpy(oid, git_object_id(object));
+		git_object_free(object);
+	}
+
+	return GIT_OK;
+}
+
+git_object *rugged_object_get(git_repository *repo, VALUE object_value, git_otype type)
+{
+	git_object *object = NULL;
+
+	if (rb_obj_is_kind_of(object_value, rb_cRuggedObject)) {
+		git_object *owned_obj = NULL;
+		Data_Get_Struct(object_value, git_object, owned_obj);
+		git_object_dup(&object, owned_obj);
+	} else {
+		int error;
+
+		Check_Type(object_value, T_STRING);
+
+		/* Fast path: if we have a 40-char string, just perform the lookup directly */
+		if (RSTRING_LEN(object_value) == 40) {
+			git_oid oid;
+
+			/* If it's not an OID, we can still try the revparse */
+			if (git_oid_fromstr(&oid, RSTRING_PTR(object_value)) == 0) {
+				error = git_object_lookup(&object, repo, &oid, type);
+				rugged_exception_check(error);
+				return object;
+			}
+		}
+
+		/* Otherwise, assume the string is a revlist and try to parse it */
+		error = git_revparse_single(&object, repo, StringValueCStr(object_value));
+		rugged_exception_check(error);
+	}
+
+	assert(object);
+
+	if (type != GIT_OBJ_ANY && git_object_type(object) != type)
+		rb_raise(rb_eArgError, "Object is not of the required type");
+
+	return object;
+}
+
+static void rb_git_object__free(git_object *object)
+{
+	git_object_free(object);
+}
+
+VALUE rugged_object_new(VALUE owner, git_object *object)
+{
+	VALUE klass, rb_object;
+
+	switch (git_object_type(object))
+	{
+		case GIT_OBJ_COMMIT:
+			klass = rb_cRuggedCommit;
+			break;
+
+		case GIT_OBJ_TAG:
+			klass = rb_cRuggedTagAnnotation;
+			break;
+
+		case GIT_OBJ_TREE:
+			klass = rb_cRuggedTree;
+			break;
+
+		case GIT_OBJ_BLOB:
+			klass = rb_cRuggedBlob;
+			break;
+
+		default:
+			rb_raise(rb_eTypeError, "Invalid type for Rugged::Object");
+			return Qnil; /* never reached */
+	}
+
+	rb_object = Data_Wrap_Struct(klass, NULL, &rb_git_object__free, object);
+	rugged_set_owner(rb_object, owner);
+	return rb_object;
+}
+
+
+static git_otype class2otype(VALUE klass)
+{
+	if (RTEST(rb_class_inherited_p(klass, rb_cRuggedCommit)))
+        return GIT_OBJ_COMMIT;
+
+	if (RTEST(rb_class_inherited_p(klass, rb_cRuggedTagAnnotation)))
+		return GIT_OBJ_TAG;
+
+	if (RTEST(rb_class_inherited_p(klass, rb_cRuggedBlob)))
+		return GIT_OBJ_BLOB;
+
+	if (RTEST(rb_class_inherited_p(klass, rb_cRuggedTree)))
+		return GIT_OBJ_TREE;
+
+	return GIT_OBJ_BAD;
+}
+
+/*
+ *  call-seq:
+ *    Object.new(repo, oid) -> object
+ *    Object.lookup(repo, oid) -> object
+ *
+ *  Find and return the git object inside +repo+ with the given +oid+.
+ *
+ *  +oid+ can either have be the complete, 40 character string or any
+ *  unique prefix.
+ */
+VALUE rb_git_object_lookup(VALUE klass, VALUE rb_repo, VALUE rb_hex)
+{
+	git_object *object;
+	git_otype type;
+	git_oid oid;
+	int error;
+	int oid_length;
+
+	git_repository *repo;
+
+	type = class2otype(klass);
+
+	if (type == GIT_OBJ_BAD)
+		type = GIT_OBJ_ANY;
+
+	Check_Type(rb_hex, T_STRING);
+	oid_length = (int)RSTRING_LEN(rb_hex);
+
+	rugged_check_repo(rb_repo);
+
+	if (oid_length > GIT_OID_HEXSZ)
+		rb_raise(rb_eTypeError, "The given OID is too long");
+
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	error = git_oid_fromstrn(&oid, RSTRING_PTR(rb_hex), oid_length);
+	rugged_exception_check(error);
+
+	if (oid_length < GIT_OID_HEXSZ)
+		error = git_object_lookup_prefix(&object, repo, &oid, oid_length, type);
+	else
+		error = git_object_lookup(&object, repo, &oid, type);
+
+	rugged_exception_check(error);
+
+	return rugged_object_new(rb_repo, object);
+}
+
+VALUE rugged_object_rev_parse(VALUE rb_repo, VALUE rb_spec, int as_obj)
+{
+	git_object *object;
+	const char *spec;
+	int error;
+	git_repository *repo;
+	VALUE ret;
+
+	Check_Type(rb_spec, T_STRING);
+	spec = RSTRING_PTR(rb_spec);
+
+	rugged_check_repo(rb_repo);
+
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	error = git_revparse_single(&object, repo, spec);
+	rugged_exception_check(error);
+
+	if (as_obj) {
+		return rugged_object_new(rb_repo, object);
+	}
+
+	ret = rugged_create_oid(git_object_id(object));
+	git_object_free(object);
+	return ret;
+}
+
+/*
+ *  call-seq: Object.rev_parse(repo, str) -> object
+ *
+ *  Find and return a single object inside +repo+ as specified by the
+ *  git revision string +str+.
+ *
+ *  See http://git-scm.com/docs/git-rev-parse.html#_specifying_revisions or
+ *  <code>man gitrevisions</code> for information on the accepted syntax.
+ *
+ *  Raises a Rugged::InvalidError if +str+ does not contain a valid revision string.
+ */
+VALUE rb_git_object_rev_parse(VALUE klass, VALUE rb_repo, VALUE rb_spec)
+{
+	return rugged_object_rev_parse(rb_repo, rb_spec, 1);
+}
+
+/*
+ *  call-seq: Object.rev_parse_oid(repo, str) -> oid
+ *
+ *  Find and return the id of the object inside +repo+ as specified by the
+ *  git revision string +str+.
+ *
+ *  See http://git-scm.com/docs/git-rev-parse.html#_specifying_revisions or
+ *  <code>man gitrevisions</code> for information on the accepted syntax.
+ *
+ *  Raises a Rugged::InvalidError if +str+ does not contain a valid revision string.
+ */
+VALUE rb_git_object_rev_parse_oid(VALUE klass, VALUE rb_repo, VALUE rb_spec)
+{
+	return rugged_object_rev_parse(rb_repo, rb_spec, 0);
+}
+
+/*
+ *  call-seq: object == other
+ *
+ *  Returns true only if +object+ and other are both instances or subclasses of
+ *  Rugged::Object and have the same object id, false otherwise.
+ */
+static VALUE rb_git_object_equal(VALUE self, VALUE other)
+{
+	git_object *a, *b;
+
+	if (!rb_obj_is_kind_of(other, rb_cRuggedObject))
+		return Qfalse;
+
+	Data_Get_Struct(self, git_object, a);
+	Data_Get_Struct(other, git_object, b);
+
+	return git_oid_cmp(git_object_id(a), git_object_id(b)) == 0 ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq: object.oid -> oid
+ *
+ *  Return the Object ID (a 40 character SHA1 hash) for +object+.
+ */
+static VALUE rb_git_object_oid_GET(VALUE self)
+{
+	git_object *object;
+	Data_Get_Struct(self, git_object, object);
+	return rugged_create_oid(git_object_id(object));
+}
+
+/*
+ *  call-seq: object.type -> type
+ *
+ *  Returns the object's type. Can be one of +:commit+, +:tag+, +:tree+ or +:blob+.
+ */
+static VALUE rb_git_object_type_GET(VALUE self)
+{
+	git_object *object;
+	Data_Get_Struct(self, git_object, object);
+
+	return rugged_otype_new(git_object_type(object));
+}
+
+/*
+ *  call-seq: object.read_raw -> raw_object
+ *
+ *  Returns the git object as a Rugged::OdbObject instance.
+ */
+static VALUE rb_git_object_read_raw(VALUE self)
+{
+	git_object *object;
+	Data_Get_Struct(self, git_object, object);
+
+	return rugged_raw_read(git_object_owner(object), git_object_id(object));
+}
+
+void Init_rugged_object(void)
+{
+	rb_cRuggedObject = rb_define_class_under(rb_mRugged, "Object", rb_cObject);
+	rb_define_singleton_method(rb_cRuggedObject, "lookup", rb_git_object_lookup, 2);
+	rb_define_singleton_method(rb_cRuggedObject, "rev_parse", rb_git_object_rev_parse, 2);
+	rb_define_singleton_method(rb_cRuggedObject, "rev_parse_oid", rb_git_object_rev_parse_oid, 2);
+	rb_define_singleton_method(rb_cRuggedObject, "new", rb_git_object_lookup, 2);
+
+	rb_define_method(rb_cRuggedObject, "read_raw", rb_git_object_read_raw, 0);
+	rb_define_method(rb_cRuggedObject, "==", rb_git_object_equal, 1);
+	rb_define_method(rb_cRuggedObject, "oid", rb_git_object_oid_GET, 0);
+	rb_define_method(rb_cRuggedObject, "type", rb_git_object_type_GET, 0);
+}