rugged 0.1.2 → 0.16.0b1

data/ext/rugged/rugged.c

@@ -0,0 +1,171 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2011 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"
+
+VALUE rb_mRugged;
+static VALUE rb_mShutdownHook;
+
+static VALUE rb_git_hex_to_raw(VALUE self, VALUE hex)
+{
+	git_oid oid;
+
+	Check_Type(hex, T_STRING);
+	rugged_exception_check(git_oid_fromstr(&oid, StringValueCStr(hex)));
+
+	return rugged_str_ascii(oid.id, 20);
+}
+
+static VALUE rb_git_raw_to_hex(VALUE self, VALUE raw)
+{
+	git_oid oid;
+	char out[40];
+
+	Check_Type(raw, T_STRING);
+	git_oid_fromraw(&oid, StringValueCStr(raw));
+	git_oid_fmt(out, &oid);
+
+	return rugged_str_new(out, 40, NULL);
+}
+
+static VALUE rb_git_type_to_string(VALUE self, VALUE type)
+{
+	const char *str;
+
+	Check_Type(type, T_FIXNUM);
+	str = git_object_type2string(FIX2INT(type));
+	return str ? rugged_str_new2(str, NULL) : Qfalse;
+}
+
+static VALUE rb_git_string_to_type(VALUE self, VALUE string_type)
+{
+	Check_Type(string_type, T_STRING);
+	return INT2FIX(git_object_string2type(StringValueCStr(string_type)));
+}
+
+static VALUE minimize_cb(VALUE rb_oid, git_oid_shorten *shortener)
+{
+	Check_Type(rb_oid, T_STRING);
+	git_oid_shorten_add(shortener, RSTRING_PTR(rb_oid));
+	return Qnil;
+}
+
+static VALUE minimize_yield(VALUE rb_oid, VALUE *data)
+{
+	rb_funcall(data[0], rb_intern("call"), 1,
+		rb_str_substr(rb_oid, 0, FIX2INT(data[1])));
+	return Qnil;
+}
+
+static VALUE rb_git_minimize_oid(int argc, VALUE *argv, VALUE self)
+{
+	git_oid_shorten *shrt;
+	int length, minlen = 7;
+	VALUE rb_enum, rb_minlen, rb_block;
+
+	rb_scan_args(argc, argv, "11&", &rb_enum, &rb_minlen, &rb_block);
+
+	if (!NIL_P(rb_minlen)) {
+		Check_Type(rb_minlen, T_FIXNUM);
+		minlen = FIX2INT(rb_minlen);
+	}
+
+	if (!rb_respond_to(rb_enum, rb_intern("each")))
+		rb_raise(rb_eTypeError, "Expecting an Enumerable instance");
+
+	shrt = git_oid_shorten_new(minlen);
+
+	rb_iterate(rb_each, rb_enum, &minimize_cb, (VALUE)shrt);
+	length = git_oid_shorten_add(shrt, NULL);
+	rugged_exception_check(length);
+
+	if (RTEST(rb_block)) {
+		VALUE yield_data[2];
+
+		yield_data[0] = rb_block;
+		yield_data[1] = INT2FIX(length);
+
+		rb_iterate(rb_each, rb_enum, &minimize_yield, (VALUE)yield_data);
+		git_oid_shorten_free(shrt);
+		return Qnil;
+	}
+
+	git_oid_shorten_free(shrt);
+	return INT2FIX(length);
+}
+
+static void cleanup_cb(void *unused)
+{
+	(void)unused;
+	git_threads_shutdown();
+}
+
+void Init_rugged()
+{
+	rb_mRugged = rb_define_module("Rugged");
+
+	rb_define_module_function(rb_mRugged, "hex_to_raw", rb_git_hex_to_raw, 1);
+	rb_define_module_function(rb_mRugged, "raw_to_hex", rb_git_raw_to_hex, 1);
+	rb_define_module_function(rb_mRugged, "type_to_string", rb_git_type_to_string, 1);
+	rb_define_module_function(rb_mRugged, "string_to_type", rb_git_string_to_type, 1);
+	rb_define_module_function(rb_mRugged, "minimize_oid", rb_git_minimize_oid, -1);
+
+	Init_rugged_object();
+	Init_rugged_commit();
+	Init_rugged_tree();
+	Init_rugged_tag();
+	Init_rugged_blob();
+
+	Init_rugged_index();
+	Init_rugged_repo();
+	Init_rugged_revwalk();
+	Init_rugged_reference();
+	Init_rugged_config();
+	Init_rugged_remote();
+
+	/* Constants */
+	rb_define_const(rb_mRugged, "SORT_NONE", INT2FIX(0));
+	rb_define_const(rb_mRugged, "SORT_TOPO", INT2FIX(1));
+	rb_define_const(rb_mRugged, "SORT_DATE", INT2FIX(2));
+	rb_define_const(rb_mRugged, "SORT_REVERSE", INT2FIX(4));
+
+	rb_define_const(rb_mRugged, "OBJ_ANY", INT2FIX(GIT_OBJ_ANY));
+	rb_define_const(rb_mRugged, "OBJ_BAD", INT2FIX(GIT_OBJ_BAD));
+	rb_define_const(rb_mRugged, "OBJ_COMMIT", INT2FIX(GIT_OBJ_COMMIT));
+	rb_define_const(rb_mRugged, "OBJ_TREE", INT2FIX(GIT_OBJ_TREE));
+	rb_define_const(rb_mRugged, "OBJ_BLOB", INT2FIX(GIT_OBJ_BLOB));
+	rb_define_const(rb_mRugged, "OBJ_TAG", INT2FIX(GIT_OBJ_TAG));
+
+	rb_define_const(rb_mRugged, "REF_OID", INT2FIX(GIT_REF_OID));
+	rb_define_const(rb_mRugged, "REF_SYMBOLIC", INT2FIX(GIT_REF_SYMBOLIC));
+
+	/* Initialize libgit2 */
+	git_threads_init();
+
+	/* Hook a global object to cleanup the library
+	 * on shutdown */
+	rb_mShutdownHook = Data_Wrap_Struct(rb_cObject, NULL, &cleanup_cb, NULL);
+	rb_global_variable(&rb_mShutdownHook);
+}
+

data/ext/rugged/rugged.h

@@ -0,0 +1,126 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2011 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.
+ */
+
+#ifndef __H_RUGGED_BINDINGS__
+#define __H_RUGGED_BINDINGS__
+
+// tell rbx not to use it's caching compat layer
+// by doing this we're making a promize to RBX that
+// we'll never modify the pointers we get back from RSTRING_PTR
+#define RSTRING_NOT_MODIFIED
+
+#include <ruby.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#	include <ruby/encoding.h>
+#endif
+
+#include <assert.h>
+#include <git2.h>
+#include <git2/odb_backend.h>
+
+/*
+ * Initialization functions 
+ */
+void Init_rugged_object();
+void Init_rugged_commit();
+void Init_rugged_tree();
+void Init_rugged_tag();
+void Init_rugged_blob();
+void Init_rugged_index();
+void Init_rugged_repo();
+void Init_rugged_revwalk();
+void Init_rugged_reference();
+void Init_rugged_config();
+void Init_rugged_remote();
+
+VALUE rb_git_object_init(git_otype type, int argc, VALUE *argv, VALUE self);
+
+VALUE rugged_raw_read(git_repository *repo, const git_oid *oid);
+
+VALUE rugged_signature_new(const git_signature *sig, const char *encoding_name);
+
+VALUE rugged_index_new(VALUE klass, VALUE owner, git_index *index);
+VALUE rugged_object_new(VALUE owner, git_object *object);
+VALUE rugged_config_new(VALUE klass, VALUE owner, git_config *cfg);
+
+git_otype rugged_get_otype(VALUE rb_type);
+
+git_signature *rugged_signature_get(VALUE rb_person);
+git_object *rugged_object_load(git_repository *repo, VALUE object_value, git_otype type);
+
+#define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
+
+static inline void rugged_set_owner(VALUE object, VALUE owner)
+{
+	rb_iv_set(object, "@owner", owner);
+}
+
+static inline VALUE rugged_owner(VALUE object)
+{
+	rb_iv_get(object, "@owner");
+}
+
+static inline void rugged_exception_check(int errorcode)
+{
+	if (errorcode < 0)
+		rb_raise(rb_eRuntimeError, "%s\n(error code %d)", git_lasterror(), errorcode);
+
+	git_clearerror();
+}
+
+static inline int rugged_parse_bool(VALUE boolean)
+{
+	if (TYPE(boolean) != T_TRUE && TYPE(boolean) != T_FALSE)
+		rb_raise(rb_eTypeError, "Expected boolean value");
+
+	return boolean ? 1 : 0;
+}
+
+/* support for string encodings in 1.9 */
+#ifdef HAVE_RUBY_ENCODING_H
+#	define rugged_str_new(str, len, enc) rb_enc_str_new(str, len, enc)
+#	define rugged_str_new2(str, enc) rb_enc_str_new(str, strlen(str), enc)
+#	define rugged_str_ascii(str, len) rb_enc_str_new(str, len, rb_ascii8bit_encoding());
+
+static VALUE rugged_str_repoenc(const char *str, long len, VALUE rb_repo)
+{
+	VALUE rb_enc = rb_iv_get(rb_repo, "@encoding");
+	return rb_enc_str_new(str, len, NIL_P(rb_enc) ? NULL : rb_to_encoding(rb_enc));
+}
+#else
+#	define rugged_str_new(str, len, rb_enc)  rb_str_new(str, len)
+#	define rugged_str_new2(str, rb_enc) rb_str_new2(str)
+#	define rugged_str_repoenc(str, len, repo) rb_str_new(str, len)
+#	define rugged_str_ascii(str, len) rb_str_new(str, len)
+#endif
+
+static inline VALUE rugged_create_oid(const git_oid *oid)
+{
+	char out[40];
+	git_oid_fmt(out, oid);
+	return rugged_str_new(out, 40, NULL);
+}
+
+#endif

data/ext/rugged/rugged_blob.c

@@ -0,0 +1,99 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2011 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_cRuggedObject;
+extern VALUE rb_cRuggedRepo;
+
+VALUE rb_cRuggedBlob;
+
+static VALUE rb_git_blob_content_GET(VALUE self)
+{
+	git_blob *blob;
+	size_t size;
+
+	Data_Get_Struct(self, git_blob, blob);
+	
+	size = git_blob_rawsize(blob);
+	if (size == 0)
+		return rugged_str_ascii("", 0);
+
+	/*
+	 * since we don't really ever know the encoding of a blob
+	 * lets default to the binary encoding (ascii-8bit)
+	 * If there is a way to tell, we should just pass 0/null here instead
+	 *
+	 * we're skipping the use of STR_NEW because we don't want our string to
+	 * eventually end up converted to Encoding.default_internal because this
+	 * string could very well be binary data
+	 */
+	return rugged_str_ascii(git_blob_rawcontent(blob), size);
+}
+
+static VALUE rb_git_blob_rawsize(VALUE self)
+{
+	git_blob *blob;
+	Data_Get_Struct(self, git_blob, blob);
+
+	return INT2FIX(git_blob_rawsize(blob));
+}
+
+static VALUE rb_git_blob_create(int argc, VALUE *argv, VALUE self)
+{
+	int error;
+	git_oid oid;
+	git_repository *repo;
+
+	VALUE rb_buffer, rb_repo, rb_is_buffer = Qfalse;
+
+	rb_scan_args(argc, argv, "21", &rb_repo, &rb_buffer, &rb_is_buffer);
+
+	Check_Type(rb_buffer, T_STRING);
+	if (!rb_obj_is_instance_of(rb_repo, rb_cRuggedRepo))
+		rb_raise(rb_eTypeError, "Expecting a Rugged Repository");
+
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	if (rugged_parse_bool(rb_is_buffer)) {
+		error = git_blob_create_frombuffer(&oid, repo, RSTRING_PTR(rb_buffer), RSTRING_LEN(rb_buffer));
+	} else {
+		error = git_blob_create_fromfile(&oid, repo, StringValueCStr(rb_buffer));
+	}
+
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&oid);
+}
+
+void Init_rugged_blob()
+{
+	rb_cRuggedBlob = rb_define_class_under(rb_mRugged, "Blob", rb_cRuggedObject);
+
+	rb_define_method(rb_cRuggedBlob, "size", rb_git_blob_rawsize, 0);
+	rb_define_method(rb_cRuggedBlob, "content", rb_git_blob_content_GET, 0);
+
+	rb_define_singleton_method(rb_cRuggedBlob, "create", rb_git_blob_create, -1);
+}

data/ext/rugged/rugged_commit.c

@@ -0,0 +1,224 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2011 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_cRuggedObject;
+extern VALUE rb_cRuggedRepo;
+extern VALUE rb_cRuggedSignature;
+VALUE rb_cRuggedCommit;
+
+/*
+ * Commit code
+ */
+static VALUE rb_git_commit_message_GET(VALUE self)
+{
+	git_commit *commit;
+
+#ifdef HAVE_RUBY_ENCODING_H
+	rb_encoding *encoding = NULL;
+	const char *encoding_name;
+#endif
+
+	Data_Get_Struct(self, git_commit, commit);
+
+#ifdef HAVE_RUBY_ENCODING_H
+	encoding_name = git_commit_message_encoding(commit);
+	if (encoding_name != NULL)
+		encoding = rb_enc_find(encoding_name);
+#endif
+
+	return rugged_str_new2(git_commit_message(commit), encoding);
+}
+
+static VALUE rb_git_commit_committer_GET(VALUE self)
+{
+	git_commit *commit;
+	Data_Get_Struct(self, git_commit, commit);
+
+	return rugged_signature_new(
+		git_commit_committer(commit),
+		git_commit_message_encoding(commit));
+}
+
+static VALUE rb_git_commit_author_GET(VALUE self)
+{
+	git_commit *commit;
+	Data_Get_Struct(self, git_commit, commit);
+
+	return rugged_signature_new(
+		git_commit_author(commit),
+		git_commit_message_encoding(commit));
+}
+
+static VALUE rb_git_commit_time_GET(VALUE self)
+{
+	git_commit *commit;
+	Data_Get_Struct(self, git_commit, commit);
+
+	return ULONG2NUM(git_commit_time(commit));
+}
+
+static VALUE rb_git_commit_tree_GET(VALUE self)
+{
+	git_commit *commit;
+	git_tree *tree;
+	VALUE owner;
+	int error;
+
+	Data_Get_Struct(self, git_commit, commit);
+	owner = rugged_owner(self);
+
+	error = git_commit_tree(&tree, commit);
+	rugged_exception_check(error);
+
+	return rugged_object_new(owner, (git_object *)tree);
+}
+
+static VALUE rb_git_commit_parents_GET(VALUE self)
+{
+	git_commit *commit;
+	git_commit *parent;
+	unsigned int n, parent_count;
+	VALUE ret_arr, owner;
+	int error;
+
+	Data_Get_Struct(self, git_commit, commit);
+	owner = rugged_owner(self);
+
+	parent_count = git_commit_parentcount(commit);
+	ret_arr = rb_ary_new2((long)parent_count);
+
+	for (n = 0; n < parent_count; n++) {
+		error = git_commit_parent(&parent, commit, n);
+		rugged_exception_check(error);
+		rb_ary_push(ret_arr, rugged_object_new(owner, (git_object *)parent));
+	}
+
+	return ret_arr;
+}
+
+static VALUE rb_git_commit_create(VALUE self, VALUE rb_repo, VALUE rb_data)
+{
+	VALUE rb_message, rb_tree, rb_parents;
+	int parent_count, i, error;
+	const git_commit **parents;
+	git_tree *tree;
+	git_signature *author, *committer;
+	git_oid commit_oid;
+	git_repository *repo;
+
+	Check_Type(rb_data, T_HASH);
+
+	if (!rb_obj_is_kind_of(rb_repo, rb_cRuggedRepo))
+		rb_raise(rb_eTypeError, "Expeting a Rugged::Repository instance");
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	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"))
+	);
+
+	author = rugged_signature_get(
+		rb_hash_aref(rb_data, CSTR2SYM("author"))
+	);
+
+	rb_parents = rb_hash_aref(rb_data, CSTR2SYM("parents"));
+	Check_Type(rb_parents, T_ARRAY);
+
+	rb_tree = rb_hash_aref(rb_data, CSTR2SYM("tree"));
+	tree = (git_tree *)rugged_object_load(repo, rb_tree, GIT_OBJ_TREE);
+
+	parent_count = (int)RARRAY_LEN(rb_parents);
+	parents = malloc(parent_count * sizeof(void*));
+
+	for (i = 0; i < parent_count; ++i) {
+		VALUE p = rb_ary_entry(rb_parents, i);
+		git_commit *parent = NULL;
+
+		if (TYPE(p) == T_STRING) {
+			git_oid oid;
+
+			error = git_oid_fromstr(&oid, StringValueCStr(p));
+			if (error < GIT_SUCCESS)
+				goto cleanup;
+
+			error = git_commit_lookup(&parent, repo, &oid);
+			if (error < GIT_SUCCESS)
+				goto cleanup;
+
+		} else if (rb_obj_is_kind_of(p, rb_cRuggedCommit)) {
+			Data_Get_Struct(p, git_commit, parent);
+		} else {
+			error = GIT_EINVALIDTYPE;
+			goto cleanup;
+		}
+
+		parents[i] = parent;
+	}
+
+	error = git_commit_create(
+		&commit_oid,
+		repo,
+		NULL,
+		author,
+		committer,
+		NULL,
+		StringValueCStr(rb_message),
+		tree,
+		parent_count,
+		parents);
+
+cleanup:
+	git_signature_free(author);
+	git_signature_free(committer);
+
+	git_object_free((git_object *)tree);
+
+	for (i = 0; i < parent_count; ++i)
+		git_object_free((git_object *)parents[i]);
+
+	free(parents);
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&commit_oid);
+}
+
+void Init_rugged_commit()
+{
+	rb_cRuggedCommit = rb_define_class_under(rb_mRugged, "Commit", rb_cRuggedObject);
+
+	rb_define_singleton_method(rb_cRuggedCommit, "create", rb_git_commit_create, 2);
+
+	rb_define_method(rb_cRuggedCommit, "message", rb_git_commit_message_GET, 0);
+	rb_define_method(rb_cRuggedCommit, "time", rb_git_commit_time_GET, 0);
+	rb_define_method(rb_cRuggedCommit, "committer", rb_git_commit_committer_GET, 0);
+	rb_define_method(rb_cRuggedCommit, "author", rb_git_commit_author_GET, 0);
+	rb_define_method(rb_cRuggedCommit, "tree", rb_git_commit_tree_GET, 0);
+	rb_define_method(rb_cRuggedCommit, "parents", rb_git_commit_parents_GET, 0);
+}
+