rugged 0.1.2 → 0.16.0b1

data/ext/rugged/rugged_revwalk.c

@@ -0,0 +1,138 @@
+/*
+ * 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;
+VALUE rb_cRuggedWalker;
+
+static void rb_git_walk__free(git_revwalk *walk)
+{
+	git_revwalk_free(walk);
+}
+
+VALUE rugged_walker_new(VALUE klass, VALUE owner, git_revwalk *walk)
+{
+	VALUE rb_walk = Data_Wrap_Struct(klass, NULL, &rb_git_walk__free, walk);
+	rugged_set_owner(rb_walk, owner);
+	return rb_walk;
+}
+
+static VALUE rb_git_walker_new(VALUE klass, VALUE rb_repo)
+{
+	git_repository *repo;
+	git_revwalk *walk;
+	int error;
+
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	error = git_revwalk_new(&walk, repo);
+	rugged_exception_check(error);
+
+	return rugged_walker_new(klass, rb_repo, walk);;
+}
+
+static VALUE rb_git_walker_each(VALUE self)
+{
+	git_revwalk *walk;
+	git_commit *commit;
+	git_repository *repo;
+	git_oid commit_oid;
+	int error;
+
+	Data_Get_Struct(self, git_revwalk, walk);
+	repo = git_revwalk_repository(walk);
+
+	if (!rb_block_given_p())
+		return rb_funcall(self, rb_intern("to_enum"), 0);
+
+	while ((error = git_revwalk_next(&commit_oid, walk)) == 0) {
+		error = git_commit_lookup(&commit, repo, &commit_oid);
+		rugged_exception_check(error);
+
+		rb_yield(rugged_object_new(rugged_owner(self), (git_object *)commit));
+	}
+
+	if (error != GIT_EREVWALKOVER)
+		rugged_exception_check(error);
+
+	return Qnil;
+}
+
+static VALUE rb_git_walker_push(VALUE self, VALUE rb_commit)
+{
+	git_revwalk *walk;
+	git_commit *commit;
+
+	Data_Get_Struct(self, git_revwalk, walk);
+
+	commit = (git_commit *)rugged_object_load(
+		git_revwalk_repository(walk), rb_commit, GIT_OBJ_COMMIT);
+
+	git_revwalk_push(walk, git_object_id((git_object *)commit));
+	return Qnil;
+}
+
+static VALUE rb_git_walker_hide(VALUE self, VALUE rb_commit)
+{
+	git_revwalk *walk;
+	git_commit *commit;
+
+	Data_Get_Struct(self, git_revwalk, walk);
+
+	commit = (git_commit *)rugged_object_load(
+		git_revwalk_repository(walk), rb_commit, GIT_OBJ_COMMIT);
+
+	git_revwalk_hide(walk, git_object_id((git_object *)commit));
+	return Qnil;
+}
+
+static VALUE rb_git_walker_sorting(VALUE self, VALUE ruby_sort_mode)
+{
+	git_revwalk *walk;
+	Data_Get_Struct(self, git_revwalk, walk);
+	git_revwalk_sorting(walk, FIX2INT(ruby_sort_mode));
+	return Qnil;
+}
+
+static VALUE rb_git_walker_reset(VALUE self)
+{
+	git_revwalk *walk;
+	Data_Get_Struct(self, git_revwalk, walk);
+	git_revwalk_reset(walk);
+	return Qnil;
+}
+
+void Init_rugged_revwalk()
+{
+	rb_cRuggedWalker = rb_define_class_under(rb_mRugged, "Walker", rb_cObject);
+	rb_define_singleton_method(rb_cRuggedWalker, "new", rb_git_walker_new, 1);
+
+	rb_define_method(rb_cRuggedWalker, "push", rb_git_walker_push, 1);
+	rb_define_method(rb_cRuggedWalker, "each", rb_git_walker_each, 0);
+	rb_define_method(rb_cRuggedWalker, "walk", rb_git_walker_each, 0);
+	rb_define_method(rb_cRuggedWalker, "hide", rb_git_walker_hide, 1);
+	rb_define_method(rb_cRuggedWalker, "reset", rb_git_walker_reset, 0);
+	rb_define_method(rb_cRuggedWalker, "sorting", rb_git_walker_sorting, 1);
+}

data/ext/rugged/rugged_signature.c

@@ -0,0 +1,80 @@
+/*
+ * 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 rugged_signature_new(const git_signature *sig, const char *encoding_name)
+{
+	VALUE rb_sig, rb_time;
+
+#ifdef HAVE_RUBY_ENCODING_H
+	rb_encoding *encoding = NULL;
+
+	if (encoding_name != NULL)
+		encoding = rb_enc_find(encoding_name);
+#endif
+
+	rb_sig = rb_hash_new();
+
+	rb_time = rb_time_new(sig->when.time, 0);
+	rb_funcall(rb_time, rb_intern("utc"), 0);
+
+	rb_hash_aset(rb_sig, CSTR2SYM("name"), rugged_str_new2(sig->name, encoding));
+	rb_hash_aset(rb_sig, CSTR2SYM("email"), rugged_str_new2(sig->email, encoding));
+	rb_hash_aset(rb_sig, CSTR2SYM("time"), rb_time);
+
+	return rb_sig;
+}
+
+git_signature *rugged_signature_get(VALUE rb_sig)
+{
+	int error;
+	VALUE rb_time, rb_unix_t, rb_offset, rb_name, rb_email;
+	git_signature *sig;
+
+	Check_Type(rb_sig, T_HASH);
+
+	rb_name = rb_hash_aref(rb_sig, rb_intern("name"));
+	rb_email = rb_hash_aref(rb_sig, rb_intern("email"));
+	rb_time = rb_hash_aref(rb_sig, rb_intern("time"));
+
+	Check_Type(rb_name, T_STRING);
+	Check_Type(rb_email, T_STRING);
+	if (!rb_obj_is_kind_of(rb_time, rb_cTime))
+		rb_raise(rb_eTypeError, "expected Time object");
+
+	rb_unix_t = rb_funcall(rb_time, rb_intern("tv_sec"), 0);
+	rb_offset = rb_funcall(rb_time, rb_intern("utc_offset"), 0);
+
+	error = git_signature_new(&sig,
+		StringValueCStr(rb_name),
+		StringValueCStr(rb_email),
+		NUM2LONG(rb_unix_t),
+		FIX2INT(rb_offset) / 60);
+
+	rugged_exception_check(error);
+
+	return sig;
+}
+

data/ext/rugged/rugged_tag.c

@@ -0,0 +1,216 @@
+/*
+ * 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_cRuggedTag;
+
+static VALUE rb_git_tag_target_GET(VALUE self)
+{
+	git_tag *tag;
+	git_object *target;
+	int error;
+	VALUE owner;
+
+	Data_Get_Struct(self, git_tag, tag);
+	owner = rugged_owner(self);
+
+	error = git_tag_target(&target, tag);
+	rugged_exception_check(error);
+
+	return rugged_object_new(owner, target);
+}
+
+static VALUE rb_git_tag_target_type_GET(VALUE self)
+{
+	git_tag *tag;
+	Data_Get_Struct(self, git_tag, tag);
+
+	return rugged_str_new2(git_object_type2string(git_tag_type(tag)), NULL);
+}
+
+static VALUE rb_git_tag_name_GET(VALUE self)
+{
+	git_tag *tag;
+	Data_Get_Struct(self, git_tag, tag);
+
+	return rugged_str_new2(git_tag_name(tag), NULL);
+}
+
+static VALUE rb_git_tag_tagger_GET(VALUE self)
+{
+	git_tag *tag;
+	Data_Get_Struct(self, git_tag, tag);
+
+	return rugged_signature_new(git_tag_tagger(tag), NULL);
+}
+
+static VALUE rb_git_tag_message_GET(VALUE self)
+{
+	git_tag *tag;
+	Data_Get_Struct(self, git_tag, tag);
+
+	return rugged_str_new2(git_tag_message(tag), NULL);
+}
+
+static VALUE rb_git_tag_create(VALUE self, VALUE rb_repo, VALUE rb_data)
+{
+	git_oid tag_oid;
+	git_repository *repo = NULL;
+	int error, force = 0;
+
+	VALUE rb_name, rb_target, rb_tagger, rb_message, rb_force;
+
+	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);
+
+	if (TYPE(rb_data) == T_STRING) {
+		error = git_tag_create_frombuffer(
+			&tag_oid,
+			repo,
+			StringValueCStr(rb_data),
+			force
+		);
+	} else if (TYPE(rb_data) == T_HASH) {
+		git_object *target = NULL;
+
+		rb_name = rb_hash_aref(rb_data, CSTR2SYM("name"));
+		Check_Type(rb_name, T_STRING);
+
+		rb_target = rb_hash_aref(rb_data, CSTR2SYM("target"));
+		target = rugged_object_load(repo, rb_target, GIT_OBJ_ANY);
+
+		rb_force = rb_hash_aref(rb_data, CSTR2SYM("force"));
+		if (!NIL_P(rb_force))
+			force = rugged_parse_bool(rb_force);
+
+		/* only for heavy tags */
+		rb_message = rb_hash_aref(rb_data, CSTR2SYM("message"));
+		rb_tagger = rb_hash_aref(rb_data, CSTR2SYM("tagger"));
+
+		if (!NIL_P(rb_tagger) && !NIL_P(rb_message)) {
+			git_signature *tagger = NULL;
+
+			tagger = rugged_signature_get(rb_tagger);
+			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);
+		} else {
+			error = git_tag_create_lightweight(
+				&tag_oid,
+				repo,
+				StringValueCStr(rb_name),
+				target,
+				force
+			);
+		}
+
+		git_object_free(target);
+	} else {
+		rb_raise(rb_eTypeError, "Invalid tag data: expected a String or a Hash");
+	}
+
+	rugged_exception_check(error);
+	return rugged_create_oid(&tag_oid);
+}
+
+static VALUE rb_git_tag_each(int argc, VALUE *argv, VALUE self)
+{
+	git_repository *repo;
+	git_strarray tags;
+	size_t i;
+	int error;
+	VALUE rb_repo, rb_pattern;
+	const char *pattern = NULL;
+
+	rb_scan_args(argc, argv, "11", &rb_repo, &rb_pattern);
+
+	if (!rb_block_given_p())
+		return rb_funcall(self, rb_intern("to_enum"), 3, CSTR2SYM("each"), rb_repo, rb_pattern);
+
+	if (!NIL_P(rb_pattern)) {
+		Check_Type(rb_pattern, T_STRING);
+		pattern = StringValueCStr(rb_pattern);
+	}
+
+	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);
+
+	error = git_tag_list_match(&tags, pattern ? pattern : "", repo);
+	rugged_exception_check(error);
+
+	for (i = 0; i < tags.count; ++i)
+		rb_yield(rugged_str_new2(tags.strings[i], NULL));
+
+	git_strarray_free(&tags);
+	return Qnil;
+}
+
+static VALUE rb_git_tag_delete(VALUE self, VALUE rb_repo, VALUE rb_name)
+{
+	git_repository *repo;
+	int error;
+
+	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);
+
+	Check_Type(rb_name, T_STRING);
+
+	error = git_tag_delete(repo, StringValueCStr(rb_name));
+	rugged_exception_check(error);
+	return Qnil;
+}
+
+void Init_rugged_tag()
+{
+	rb_cRuggedTag = rb_define_class_under(rb_mRugged, "Tag", rb_cRuggedObject);
+
+	rb_define_singleton_method(rb_cRuggedTag, "create", rb_git_tag_create, 2);
+	rb_define_singleton_method(rb_cRuggedTag, "each", rb_git_tag_each, -1);
+	rb_define_singleton_method(rb_cRuggedTag, "delete", rb_git_tag_delete, 2);
+
+	rb_define_method(rb_cRuggedTag, "message", rb_git_tag_message_GET, 0);
+	rb_define_method(rb_cRuggedTag, "name", rb_git_tag_name_GET, 0);
+	rb_define_method(rb_cRuggedTag, "target", rb_git_tag_target_GET, 0);
+	rb_define_method(rb_cRuggedTag, "target_type", rb_git_tag_target_type_GET, 0);
+	rb_define_method(rb_cRuggedTag, "tagger", rb_git_tag_tagger_GET, 0);
+}

data/ext/rugged/rugged_tree.c

@@ -0,0 +1,322 @@
+/*
+ * 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_cRuggedTree;
+VALUE rb_cRuggedTreeBuilder;
+
+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"), rugged_str_new2(git_tree_entry_name(entry), NULL));
+	rb_hash_aset(rb_entry, CSTR2SYM("oid"), rugged_create_oid(git_tree_entry_id(entry)));
+
+	rb_hash_aset(rb_entry, CSTR2SYM("attributes"), INT2FIX(git_tree_entry_attributes(entry)));
+
+	switch(git_tree_entry_type(entry)) {
+		case GIT_OBJ_TREE:
+			type = CSTR2SYM("tree");
+			break;
+
+		case GIT_OBJ_BLOB:
+			type = CSTR2SYM("blob");
+			break;
+
+		default:
+			type = Qnil;
+			break;
+	}
+	rb_hash_aset(rb_entry, CSTR2SYM("type"), type);
+
+	return rb_entry;
+}
+
+/*
+ * Rugged Tree
+ */
+static VALUE rb_git_tree_entrycount(VALUE self)
+{
+	git_tree *tree;
+	Data_Get_Struct(self, git_tree, tree);
+
+	return INT2FIX(git_tree_entrycount(tree));
+}
+
+static VALUE rb_git_tree_get_entry(VALUE self, VALUE entry_id)
+{
+	git_tree *tree;
+	Data_Get_Struct(self, git_tree, tree);
+
+	if (TYPE(entry_id) == T_FIXNUM)
+		return rb_git_treeentry_fromC(git_tree_entry_byindex(tree, FIX2INT(entry_id)));
+
+	else if (TYPE(entry_id) == T_STRING)
+		return rb_git_treeentry_fromC(git_tree_entry_byname(tree, StringValueCStr(entry_id)));
+
+	else
+		rb_raise(rb_eTypeError, "entry_id must be either an index or a filename");
+}
+
+static VALUE rb_git_tree_each(VALUE self)
+{
+	git_tree *tree;
+	unsigned int i, count;
+	Data_Get_Struct(self, git_tree, tree);
+
+	if (!rb_block_given_p())
+		return rb_funcall(self, rb_intern("to_enum"), 0);
+
+	count = git_tree_entrycount(tree);
+
+	for (i = 0; i < count; ++i) {
+		const git_tree_entry *entry = git_tree_entry_byindex(tree, i);
+		rb_yield(rb_git_treeentry_fromC(entry));
+	}
+
+	return Qnil;
+}
+
+static int rugged__treewalk_cb(const char *root, git_tree_entry *entry, void *proc)
+{
+	rb_funcall((VALUE)proc, rb_intern("call"), 2,
+		rugged_str_new2(root, NULL),
+		rb_git_treeentry_fromC(entry));
+
+	return GIT_SUCCESS;
+}
+
+static VALUE rb_git_tree_walk(VALUE self, VALUE rb_mode)
+{
+	git_tree *tree;
+	int error, mode = 0;
+	ID id_mode;
+
+	Data_Get_Struct(self, git_tree, tree);
+
+	if (!rb_block_given_p())
+		return rb_funcall(self, rb_intern("to_enum"), 2, CSTR2SYM("walk"), rb_mode);
+
+	Check_Type(rb_mode, T_SYMBOL);
+	id_mode = SYM2ID(rb_mode);
+
+	if (id_mode == rb_intern("preorder"))
+		mode = GIT_TREEWALK_PRE;
+	else if (id_mode == rb_intern("postorder"))
+		mode = GIT_TREEWALK_POST;
+	else
+		rb_raise(rb_eTypeError,
+			"Invalid iteration mode. Expected `:preorder` or `:postorder`");
+
+	error = git_tree_walk(tree, &rugged__treewalk_cb, mode, (void *)rb_block_proc());
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+static VALUE rb_git_tree_subtree(VALUE self, VALUE rb_path)
+{
+	int error;
+	git_tree *tree, *subtree;
+	VALUE owner;
+
+	Data_Get_Struct(self, git_tree, tree);
+	owner = rugged_owner(self);
+
+	Check_Type(rb_path, T_STRING);
+
+	error = git_tree_get_subtree(&subtree, tree, StringValueCStr(rb_path));
+	rugged_exception_check(error);
+
+	return rugged_object_new(owner, (git_object *)subtree);
+}
+
+static void rb_git_treebuilder_free(git_treebuilder *bld)
+{
+	git_treebuilder_free(bld);
+}
+
+static VALUE rb_git_treebuilder_allocate(VALUE klass)
+{
+	return Data_Wrap_Struct(klass, NULL, &rb_git_treebuilder_free, NULL);
+}
+
+static VALUE rb_git_treebuilder_init(int argc, VALUE *argv, VALUE self)
+{
+	git_treebuilder *builder;
+	git_tree *tree = NULL;
+	VALUE rb_object;
+	int error;
+
+	if (rb_scan_args(argc, argv, "01", &rb_object) == 1) {
+		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);
+	}
+
+	error = git_treebuilder_create(&builder, tree);
+	rugged_exception_check(error);
+
+	DATA_PTR(self) = builder;
+	return Qnil;
+}
+
+static VALUE rb_git_treebuilder_clear(VALUE self)
+{
+	git_treebuilder *builder;
+	Data_Get_Struct(self, git_treebuilder, builder);
+	git_treebuilder_clear(builder);
+	return Qnil;
+}
+
+static VALUE rb_git_treebuilder_get(VALUE self, VALUE path)
+{
+	git_treebuilder *builder;
+	Data_Get_Struct(self, git_treebuilder, builder);
+
+	Check_Type(path, T_STRING);
+
+	return rb_git_treeentry_fromC(git_treebuilder_get(builder, StringValueCStr(path)));
+}
+
+static VALUE rb_git_treebuilder_insert(VALUE self, VALUE rb_entry)
+{
+	git_treebuilder *builder;
+	VALUE rb_path, rb_oid, rb_attr;
+	git_oid oid;
+	int error;
+
+	Data_Get_Struct(self, git_treebuilder, builder);
+	Check_Type(rb_entry, T_HASH);
+
+	rb_path = rb_hash_aref(rb_entry, CSTR2SYM("path"));
+	Check_Type(rb_path, T_STRING);
+
+	rb_oid = rb_hash_aref(rb_entry, CSTR2SYM("oid"));
+	Check_Type(rb_oid, T_STRING);
+	rugged_exception_check(git_oid_fromstr(&oid, StringValueCStr(rb_oid)));
+
+	rb_attr = rb_hash_aref(rb_entry, CSTR2SYM("attributes"));
+	Check_Type(rb_attr, T_FIXNUM);
+
+	error = git_treebuilder_insert(NULL,
+		builder,
+		StringValueCStr(rb_path),
+		&oid,
+		FIX2INT(rb_attr));
+
+	rugged_exception_check(error);
+	return Qnil;
+}
+
+static VALUE rb_git_treebuilder_remove(VALUE self, VALUE path)
+{
+	git_treebuilder *builder;
+	int error;
+
+	Data_Get_Struct(self, git_treebuilder, builder);
+	Check_Type(path, T_STRING);
+
+	error = git_treebuilder_remove(builder, StringValueCStr(path));
+	if (error == GIT_ENOTFOUND)
+		return Qfalse;
+
+	rugged_exception_check(error);
+	return Qtrue;
+}
+
+static VALUE rb_git_treebuilder_write(VALUE self, VALUE rb_repo)
+{
+	git_treebuilder *builder;
+	git_repository *repo;
+	git_oid written_id;
+	int error;
+
+	if (!rb_obj_is_kind_of(rb_repo, rb_cRuggedRepo))
+		rb_raise(rb_eTypeError, "Expecting a Rugged::Repository instance");
+
+	Data_Get_Struct(self, git_treebuilder, builder);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	error = git_treebuilder_write(&written_id, repo, builder);
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&written_id);
+}
+
+static int treebuilder_cb(const git_tree_entry *entry, void *opaque)
+{
+	VALUE proc = (VALUE)opaque;
+	VALUE ret = rb_funcall(proc, rb_intern("call"), 1, rb_git_treeentry_fromC(entry));
+	return rugged_parse_bool(ret);
+}
+
+static VALUE rb_git_treebuilder_filter(VALUE self)
+{
+	git_treebuilder *builder;
+
+	rb_need_block();
+	Data_Get_Struct(self, git_treebuilder, builder);
+
+	git_treebuilder_filter(builder, &treebuilder_cb, (void *)rb_block_proc());
+	return Qnil;
+}
+
+void Init_rugged_tree()
+{
+	/*
+	 * Tree
+	 */
+	rb_cRuggedTree = rb_define_class_under(rb_mRugged, "Tree", rb_cRuggedObject);
+	rb_define_method(rb_cRuggedTree, "count", rb_git_tree_entrycount, 0);
+	rb_define_method(rb_cRuggedTree, "length", rb_git_tree_entrycount, 0);
+	rb_define_method(rb_cRuggedTree, "get_entry", rb_git_tree_get_entry, 1);
+	rb_define_method(rb_cRuggedTree, "get_subtree", rb_git_tree_subtree, 1);
+	rb_define_method(rb_cRuggedTree, "[]", rb_git_tree_get_entry, 1);
+	rb_define_method(rb_cRuggedTree, "each", rb_git_tree_each, 0);
+	rb_define_method(rb_cRuggedTree, "walk", rb_git_tree_walk, 1);
+
+	rb_cRuggedTreeBuilder = rb_define_class_under(rb_cRuggedTree, "Builder", rb_cObject);
+	rb_define_alloc_func(rb_cRuggedTreeBuilder, rb_git_treebuilder_allocate);
+	rb_define_method(rb_cRuggedTreeBuilder, "initialize", rb_git_treebuilder_init, -1);
+	rb_define_method(rb_cRuggedTreeBuilder, "clear", rb_git_treebuilder_clear, 0);
+	rb_define_method(rb_cRuggedTreeBuilder, "[]", rb_git_treebuilder_get, 1);
+	rb_define_method(rb_cRuggedTreeBuilder, "insert", rb_git_treebuilder_insert, 1);
+	rb_define_method(rb_cRuggedTreeBuilder, "<<", rb_git_treebuilder_insert, 1);
+	rb_define_method(rb_cRuggedTreeBuilder, "remove", rb_git_treebuilder_remove, 1);
+	rb_define_method(rb_cRuggedTreeBuilder, "write", rb_git_treebuilder_write, 1);
+	rb_define_method(rb_cRuggedTreeBuilder, "reject!", rb_git_treebuilder_filter, 0);
+}