rugged 0.17.0.b7 → 0.18.0.b1

data/ext/rugged/rugged_blob.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2011 GitHub, Inc
+ * Copyright (c) 2013 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
@@ -172,8 +172,7 @@ static VALUE rb_git_blob_create(VALUE self, VALUE rb_repo, VALUE rb_buffer)
 	git_repository *repo;
 
 	Check_Type(rb_buffer, T_STRING);
-	if (!rb_obj_is_instance_of(rb_repo, rb_cRuggedRepo))
-		rb_raise(rb_eTypeError, "Expecting a Rugged Repository");
+	rugged_check_repo(rb_repo);
 
 	Data_Get_Struct(rb_repo, git_repository, repo);
 
@@ -185,26 +184,25 @@ static VALUE rb_git_blob_create(VALUE self, VALUE rb_repo, VALUE rb_buffer)
 
 /*
  *	call-seq:
- *		Blob.write_file(repository, file_path) -> oid
+ *		Blob.from_workdir(repository, file_path) -> oid
  *
  *	Write the file specified in +file_path+ to a blob in +repository+.
  *	+file_path+ must be relative to the repository's working folder.
  *
- *		Blob.write_file(repo, 'src/blob.h') #=> '9d09060c850defbc7711d08b57def0d14e742f4e'
+ *		Blob.from_workdir(repo, 'src/blob.h') #=> '9d09060c850defbc7711d08b57def0d14e742f4e'
  */
-static VALUE rb_git_blob_writefile(VALUE self, VALUE rb_repo, VALUE rb_path)
+static VALUE rb_git_blob_from_workdir(VALUE self, VALUE rb_repo, VALUE rb_path)
 {
 	int error;
 	git_oid oid;
 	git_repository *repo;
 
 	Check_Type(rb_path, T_STRING);
-	if (!rb_obj_is_instance_of(rb_repo, rb_cRuggedRepo))
-		rb_raise(rb_eTypeError, "Expecting a Rugged Repository");
+	rugged_check_repo(rb_repo);
 
 	Data_Get_Struct(rb_repo, git_repository, repo);
 
-	error = git_blob_create_fromfile(&oid, repo, StringValueCStr(rb_path));
+	error = git_blob_create_fromworkdir(&oid, repo, StringValueCStr(rb_path));
 	rugged_exception_check(error);
 
 	return rugged_create_oid(&oid);
@@ -259,5 +257,5 @@ void Init_rugged_blob()
 	rb_define_method(rb_cRuggedBlob, "sloc", rb_git_blob_sloc, 0);
 
 	rb_define_singleton_method(rb_cRuggedBlob, "create", rb_git_blob_create, 2);
-	rb_define_singleton_method(rb_cRuggedBlob, "write_file", rb_git_blob_writefile, 2);
+	rb_define_singleton_method(rb_cRuggedBlob, "from_workdir", rb_git_blob_from_workdir, 2);
 }

data/ext/rugged/rugged_branch.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2012 GitHub, Inc
+ * Copyright (c) 2013 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
@@ -62,7 +62,7 @@ static int parse_branch_type(VALUE rb_filter)
  *	+name+ needs to be a branch name, not an absolute reference path
  *	(e.g. 'development' instead of '/refs/heads/development')
  *
- *	+target+ needs to be an existing object (of any type) in the given +repository+.
+ *	+target+ needs to be an existing commit in the given +repository+.
  *
  *	If +force+ is +true+, any existing branches will be overwritten.
  *
@@ -71,7 +71,7 @@ static int parse_branch_type(VALUE rb_filter)
 static VALUE rb_git_branch_create(int argc, VALUE *argv, VALUE self)
 {
 	git_reference *branch;
-	git_object *target = NULL;
+	git_commit *target = NULL;
 	git_repository *repo = NULL;
 	int error, force = 0;
 
@@ -87,14 +87,14 @@ static VALUE rb_git_branch_create(int argc, VALUE *argv, VALUE self)
 
 	Check_Type(rb_name, T_STRING);
 
-	target = rugged_object_load(repo, rb_target, GIT_OBJ_ANY);
+	target = (git_commit *)rugged_object_get(repo, rb_target, GIT_OBJ_COMMIT);
 
 	if (!NIL_P(rb_force)) {
 		force = rugged_parse_bool(rb_force);
 	}
 
 	error = git_branch_create(&branch, repo, StringValueCStr(rb_name), target, force);
-	git_object_free(target);
+	git_commit_free(target);
 
 	rugged_exception_check(error);
 
@@ -142,7 +142,6 @@ static VALUE rb_git_branch_lookup(int argc, VALUE *argv, VALUE self)
 		return Qnil;
 
 	rugged_exception_check(error);
-
 	return rugged_branch_new(rb_repo, branch);
 }
 
@@ -157,14 +156,12 @@ static VALUE rb_git_branch_delete(VALUE self)
 {
 	git_reference *branch = NULL;
 
-	RUGGED_UNPACK_REFERENCE(self, branch);
+	Data_Get_Struct(self, git_reference, branch);
 
 	rugged_exception_check(
 		git_branch_delete(branch)
 	);
 
-	DATA_PTR(self) = NULL; /* this reference has been free'd */
-	rugged_set_owner(self, Qnil); /* and is no longer owned */
 	return Qnil;
 }
 
@@ -188,7 +185,7 @@ static int cb_branch__each_obj(const char *branch_name, git_branch_t branch_type
 	);
 
 	rb_yield(rugged_branch_new(rb_repo, branch));
-	return GIT_OK;
+	return 0;
 }
 
 static VALUE each_branch(int argc, VALUE *argv, VALUE self, int branch_names_only)
@@ -274,21 +271,21 @@ static VALUE rb_git_branch_each(int argc, VALUE *argv, VALUE self)
 static VALUE rb_git_branch_move(int argc, VALUE *argv, VALUE self)
 {
 	VALUE rb_new_branch_name, rb_force;
-	git_reference *old_branch = NULL;
+	git_reference *old_branch = NULL, *new_branch = NULL;
 	int error, force = 0;
 
 	rb_scan_args(argc, argv, "11", &rb_new_branch_name, &rb_force);
 
-	RUGGED_UNPACK_REFERENCE(self, old_branch);
+	Data_Get_Struct(self, git_reference, old_branch);
 	Check_Type(rb_new_branch_name, T_STRING);
 
 	if (!NIL_P(rb_force))
 		force = rugged_parse_bool(rb_force);
 
-	error = git_branch_move(old_branch, StringValueCStr(rb_new_branch_name), force);
+	error = git_branch_move(&new_branch, old_branch, StringValueCStr(rb_new_branch_name), force);
 	rugged_exception_check(error);
 
-	return Qnil;
+	return rugged_branch_new(rugged_owner(self), new_branch);
 }
 
 void Init_rugged_branch()

data/ext/rugged/rugged_commit.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2011 GitHub, Inc
+ * Copyright (c) 2013 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
@@ -159,23 +159,23 @@ static VALUE rb_git_commit_tree_GET(VALUE self)
 
 /*
  *	call-seq:
- *		commit.tree_oid -> oid
+ *		commit.tree_id -> oid
  *
  *	Return the tree oid pointed at by this +commit+. The tree is
  *	returned as a String object.
  *
- *		commit.tree #=> "f148106ca58764adc93ad4e2d6b1d168422b9796"
+ *		commit.tree_id #=> "f148106ca58764adc93ad4e2d6b1d168422b9796"
  */
-static VALUE rb_git_commit_tree_oid_GET(VALUE self)
+static VALUE rb_git_commit_tree_id_GET(VALUE self)
 {
 	git_commit *commit;
-	const git_oid *tree_oid;
+	const git_oid *tree_id;
 
 	Data_Get_Struct(self, git_commit, commit);
 
-	tree_oid = git_commit_tree_oid(commit);
+	tree_id = git_commit_tree_id(commit);
 
-	return rugged_create_oid(tree_oid);
+	return rugged_create_oid(tree_id);
 }
 
 /*
@@ -214,19 +214,19 @@ static VALUE rb_git_commit_parents_GET(VALUE self)
 
 /*
  *	call-seq:
- *		commit.parent_oids -> [oid, ...]
+ *		commit.parent_ids -> [oid, ...]
  *
  *	Return the parent oid(s) of this commit as an array of oid String
  *	objects. An array is always returned even when the commit has only
  *	one or zero parents.
  *
- *		commit.parent_oids #=> => ["2cb831a8aea28b2c1b9c63385585b864e4d3bad1", ...]
- *		root.parent_oids #=> []
+ *		commit.parent_ids #=> => ["2cb831a8aea28b2c1b9c63385585b864e4d3bad1", ...]
+ *		root.parent_ids #=> []
  */
-static VALUE rb_git_commit_parent_oids_GET(VALUE self)
+static VALUE rb_git_commit_parent_ids_GET(VALUE self)
 {
 	git_commit *commit;
-	const git_oid *parent_oid;
+	const git_oid *parent_id;
 	unsigned int n, parent_count;
 	VALUE ret_arr;
 
@@ -236,9 +236,9 @@ static VALUE rb_git_commit_parent_oids_GET(VALUE self)
 	ret_arr = rb_ary_new2((long)parent_count);
 
 	for (n = 0; n < parent_count; n++) {
-		parent_oid = git_commit_parent_oid(commit, n);
-		if (parent_oid) {
-			rb_ary_push(ret_arr, rugged_create_oid(parent_oid));
+		parent_id = git_commit_parent_id(commit, n);
+		if (parent_id) {
+			rb_ary_push(ret_arr, rugged_create_oid(parent_id));
 		}
 	}
 
@@ -277,7 +277,8 @@ static VALUE rb_git_commit_parent_oids_GET(VALUE self)
 static VALUE rb_git_commit_create(VALUE self, VALUE rb_repo, VALUE rb_data)
 {
 	VALUE rb_message, rb_tree, rb_parents, rb_ref;
-	int parent_count, i, error;
+	VALUE rb_err_obj = Qnil;
+	int parent_count, i, error = 0;
 	const git_commit **parents = NULL;
 	git_commit **free_list = NULL;
 	git_tree *tree;
@@ -313,10 +314,10 @@ static VALUE rb_git_commit_create(VALUE self, VALUE rb_repo, VALUE rb_data)
 	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);
+	tree = (git_tree *)rugged_object_get(repo, rb_tree, GIT_OBJ_TREE);
 
-	parents = xmalloc(RARRAY_LEN(rb_parents) * sizeof(void *));
-	free_list = xmalloc(RARRAY_LEN(rb_parents) * sizeof(void *));
+	parents = alloca(RARRAY_LEN(rb_parents) * sizeof(void *));
+	free_list = alloca(RARRAY_LEN(rb_parents) * sizeof(void *));
 	parent_count = 0;
 
 	for (i = 0; i < (int)RARRAY_LEN(rb_parents); ++i) {
@@ -343,7 +344,8 @@ static VALUE rb_git_commit_create(VALUE self, VALUE rb_repo, VALUE rb_data)
 		} else if (rb_obj_is_kind_of(p, rb_cRuggedCommit)) {
 			Data_Get_Struct(p, git_commit, parent);
 		} else {
-			rb_raise(rb_eTypeError, "Invalid type for parent object");
+			rb_err_obj = rb_exc_new2(rb_eTypeError, "Invalid type for parent object");
+			goto cleanup;
 		}
 
 		parents[parent_count] = parent;
@@ -372,8 +374,9 @@ cleanup:
 	for (i = 0; i < parent_count; ++i)
 		git_object_free((git_object *)free_list[i]);
 
-	xfree(parents);
-	xfree(free_list);
+	if (!NIL_P(rb_err_obj))
+		rb_exc_raise(rb_err_obj);
+
 	rugged_exception_check(error);
 
 	return rugged_create_oid(&commit_oid);
@@ -390,8 +393,12 @@ void Init_rugged_commit()
 	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, "tree_oid", rb_git_commit_tree_oid_GET, 0);
+
+	rb_define_method(rb_cRuggedCommit, "tree_id", rb_git_commit_tree_id_GET, 0);
+	rb_define_method(rb_cRuggedCommit, "tree_oid", rb_git_commit_tree_id_GET, 0);
+
 	rb_define_method(rb_cRuggedCommit, "parents", rb_git_commit_parents_GET, 0);
-	rb_define_method(rb_cRuggedCommit, "parent_oids", rb_git_commit_parent_oids_GET, 0);
+	rb_define_method(rb_cRuggedCommit, "parent_ids", rb_git_commit_parent_ids_GET, 0);
+	rb_define_method(rb_cRuggedCommit, "parent_oids", rb_git_commit_parent_ids_GET, 0);
 }
 

data/ext/rugged/rugged_config.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2011 GitHub, Inc
+ * Copyright (c) 2013 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
@@ -170,7 +170,7 @@ static VALUE rb_git_config_delete(VALUE self, VALUE rb_key)
 	Data_Get_Struct(self, git_config, config);
 	Check_Type(rb_key, T_STRING);
 
-	error = git_config_delete(config, StringValueCStr(rb_key));
+	error = git_config_delete_entry(config, StringValueCStr(rb_key));
 	if (error == GIT_ENOTFOUND)
 		return Qfalse;
 

data/ext/rugged/rugged_index.c

@@ -1,18 +1,18 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2011 GitHub, Inc
- * 
+ * Copyright (c) 2013 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
@@ -28,14 +28,13 @@ extern VALUE rb_mRugged;
 VALUE rb_cRuggedIndex;
 
 static void rb_git_indexentry_toC(git_index_entry *entry, VALUE rb_entry);
-static VALUE rb_git_indexentry_fromC(git_index_entry *entry);
-static VALUE rb_git_unmerged_fromC(const git_index_entry_unmerged *entry);
+static VALUE rb_git_indexentry_fromC(const git_index_entry *entry);
 
 /*
  * Index
  */
 
-void rb_git_index__free(git_index *index)
+static void rb_git_index__free(git_index *index)
 {
 	git_index_free(index);
 }
@@ -47,14 +46,20 @@ VALUE rugged_index_new(VALUE klass, VALUE owner, git_index *index)
 	return rb_index;
 }
 
-static VALUE rb_git_index_new(VALUE klass, VALUE path)
+static VALUE rb_git_index_new(int argc, VALUE *argv, VALUE klass)
 {
 	git_index *index;
 	int error;
 
-	Check_Type(path, T_STRING);
+	VALUE rb_path;
+	const char *path = NULL;
+
+	if (rb_scan_args(argc, argv, "01", &rb_path) == 1) {
+		Check_Type(rb_path, T_STRING);
+		path = StringValueCStr(rb_path);
+	}
 
-	error = git_index_open(&index, StringValueCStr(path));
+	error = git_index_open(&index, path);
 	rugged_exception_check(error);
 
 	return rugged_index_new(klass, Qnil, index);
@@ -90,15 +95,7 @@ static VALUE rb_git_index_write(VALUE self)
 
 	error = git_index_write(index);
 	rugged_exception_check(error);
-		
-	return Qnil;
-}
 
-static VALUE rb_git_index_uniq(VALUE self)
-{
-	git_index *index;
-	Data_Get_Struct(self, git_index, index);
-	git_index_uniq(index);
 	return Qnil;
 }
 
@@ -109,23 +106,41 @@ static VALUE rb_git_index_count(VALUE self)
 	return INT2FIX(git_index_entrycount(index));
 }
 
-static VALUE rb_git_index_count_unmerged(VALUE self)
+static VALUE rb_git_index_get(int argc, VALUE *argv, VALUE self)
 {
 	git_index *index;
-	Data_Get_Struct(self, git_index, index);
-	return INT2FIX(git_index_entrycount_unmerged(index));
-}
+	const git_index_entry *entry = NULL;
+
+	VALUE rb_entry, rb_stage;
 
-static VALUE rb_git_index_get(VALUE self, VALUE entry)
-{
-	git_index *index;
 	Data_Get_Struct(self, git_index, index);
 
-	if (TYPE(entry) == T_STRING)
-		entry = INT2FIX(git_index_find(index, StringValueCStr(entry)));
+	rb_scan_args(argc, argv, "11", &rb_entry, &rb_stage);
+
+	if (TYPE(rb_entry) == T_STRING) {
+		int stage = 0;
+
+		if (!NIL_P(rb_stage)) {
+			Check_Type(rb_stage, T_FIXNUM);
+			stage = FIX2INT(rb_stage);
+		}
+
+		entry = git_index_get_bypath(index, StringValueCStr(rb_entry), stage);
+	}
+
+	else if (TYPE(rb_entry) == T_FIXNUM) {
+		if (argc > 1) {
+			rb_raise(rb_eArgError,
+				"Too many arguments when trying to lookup entry by index");
+		}
+
+		entry = git_index_get_byindex(index, FIX2INT(rb_entry));
+	} else {
+		rb_raise(rb_eArgError,
+			"Invalid type for `entry`: expected String or Fixnum");
+	}
 
-	Check_Type(entry, T_FIXNUM);
-	return rb_git_indexentry_fromC(git_index_get(index, FIX2INT(entry)));
+	return entry ? rb_git_indexentry_fromC(entry) : Qnil;
 }
 
 static VALUE rb_git_index_each(VALUE self)
@@ -138,9 +153,9 @@ static VALUE rb_git_index_each(VALUE self)
 	if (!rb_block_given_p())
 		return rb_funcall(self, rb_intern("to_enum"), 0);
 
-	count = git_index_entrycount(index);
+	count = (unsigned int)git_index_entrycount(index);
 	for (i = 0; i < count; ++i) {
-		git_index_entry *entry = git_index_get(index, i);
+		const git_index_entry *entry = git_index_get_byindex(index, i);
 		if (entry)
 			rb_yield(rb_git_indexentry_fromC(entry));
 	}
@@ -148,87 +163,47 @@ static VALUE rb_git_index_each(VALUE self)
 	return Qnil;
 }
 
-static VALUE rb_git_index_get_unmerged(VALUE self, VALUE entry)
+static VALUE rb_git_index_remove(int argc, VALUE *argv, VALUE self)
 {
 	git_index *index;
-	Data_Get_Struct(self, git_index, index);
-
-	if (TYPE(entry) == T_STRING)
-		return rb_git_unmerged_fromC(git_index_get_unmerged_bypath(index, StringValueCStr(entry)));
-
-	if (TYPE(entry) == T_FIXNUM)
-		return rb_git_unmerged_fromC(git_index_get_unmerged_byindex(index, FIX2INT(entry)));
+	int error, stage = 0;
 
-	rb_raise(rb_eTypeError, "Expecting a path name or index for unmerged entries");
-}
+	VALUE rb_entry, rb_stage;
 
-static VALUE rb_git_index_remove(VALUE self, VALUE entry)
-{
-	git_index *index;
-	int error;
 	Data_Get_Struct(self, git_index, index);
 
-	if (TYPE(entry) == T_STRING)
-		entry = INT2FIX(git_index_find(index, StringValueCStr(entry)));
+	if (rb_scan_args(argc, argv, "11", &rb_entry, &rb_stage) > 1) {
+		Check_Type(rb_stage, T_FIXNUM);
+		stage = FIX2INT(rb_stage);
+	}
+
+	Check_Type(rb_entry, T_STRING);
 
-	Check_Type(entry, T_FIXNUM);
-	
-	error = git_index_remove(index, FIX2INT(entry));
+	error = git_index_remove(index, StringValueCStr(rb_entry), stage);
 	rugged_exception_check(error);
 
 	return Qnil;
 }
 
-static VALUE rb_git_index_add(int argc, VALUE *argv, VALUE self)
+static VALUE rb_git_index_add(VALUE self, VALUE rb_entry)
 {
 	git_index *index;
-	int error;
-	VALUE rb_entry, rb_stage;
-
-	rb_scan_args(argc, argv, "11", &rb_entry, &rb_stage);
+	int error = 0;
 
 	Data_Get_Struct(self, git_index, index);
 
 	if (TYPE(rb_entry) == T_HASH) {
 		git_index_entry entry;
-		if (argc > 1)
-			rb_raise(rb_eTypeError,
-				"Wrong number or arguments (only an Index Entry is expected");
 
 		rb_git_indexentry_toC(&entry, rb_entry);
-		error = git_index_add2(index, &entry);
-	} else if (TYPE(rb_entry) == T_STRING) {
-		int stage = 0;
-		if (!NIL_P(rb_stage))
-			stage = NUM2INT(rb_stage);
-		error = git_index_add(index, StringValueCStr(rb_entry), stage);
-	} else {
-		rb_raise(rb_eTypeError, 
-			"Expecting a hash defining an Index Entry or a path to a file in the repository");
+		error = git_index_add(index, &entry);
 	}
 
-	rugged_exception_check(error);
-	return Qnil;
-}
-
-static VALUE rb_git_index_append(int argc, VALUE *argv, VALUE self)
-{
-	git_index *index;
-	int error;
-	VALUE rb_entry, rb_stage;
-
-	rb_scan_args(argc, argv, "11", &rb_entry, &rb_stage);
-
-	Data_Get_Struct(self, git_index, index);
+	else if (TYPE(rb_entry) == T_STRING) {
+		error = git_index_add_bypath(index, StringValueCStr(rb_entry));
+	}
 
-	if (TYPE(rb_entry) == T_HASH) {
-		git_index_entry entry;
-		rb_git_indexentry_toC(&entry, rb_entry);
-		error = git_index_append2(index, &entry);
-	} else if (TYPE(rb_entry) == T_STRING) {
-		Check_Type(rb_stage, T_FIXNUM);
-		error = git_index_append(index, StringValueCStr(rb_entry), FIX2INT(rb_stage));
-	} else {
+	else {
 		rb_raise(rb_eTypeError,
 			"Expecting a hash defining an Index Entry or a path to a file in the repository");
 	}
@@ -238,35 +213,7 @@ static VALUE rb_git_index_append(int argc, VALUE *argv, VALUE self)
 }
 
 
-/*
- * Index Entry
- */
-static VALUE rb_git_unmerged_fromC(const git_index_entry_unmerged *entry)
-{
-	int i;
-	VALUE rb_entry, rb_modes, rb_oids;
-
-	if (!entry)
-		return Qnil;
-
-	rb_modes = rb_ary_new2(3);
-	rb_oids = rb_ary_new2(3);
-	for (i = 0; i < 3; ++i) {
-		rb_ary_push(rb_modes, INT2FIX(entry->mode[i]));
-		rb_ary_push(rb_oids, rugged_create_oid(&entry->oid[i]));
-	}
-
-	rb_entry = rb_hash_new();
-	rb_hash_aset(rb_entry, CSTR2SYM("path"), rugged_str_new2(entry->path, NULL));
-	rb_hash_aset(rb_entry, CSTR2SYM("oids"), rb_oids);
-	rb_hash_aset(rb_entry, CSTR2SYM("modes"), rb_modes);
-
-	return rb_entry;
-}
-
-
-
-static VALUE rb_git_indexentry_fromC(git_index_entry *entry)
+static VALUE rb_git_indexentry_fromC(const git_index_entry *entry)
 {
 	VALUE rb_entry, rb_mtime, rb_ctime;
 	unsigned int valid, stage;
@@ -301,39 +248,59 @@ static VALUE rb_git_indexentry_fromC(git_index_entry *entry)
 	return rb_entry;
 }
 
+static inline unsigned int
+default_entry_value(VALUE rb_entry, const char *key)
+{
+	VALUE val = rb_hash_aref(rb_entry, CSTR2SYM(key));
+	if (NIL_P(val))
+		return 0;
+
+	Check_Type(val, T_FIXNUM);
+	return FIX2INT(val);
+}
+
 static void rb_git_indexentry_toC(git_index_entry *entry, VALUE rb_entry)
 {
 	VALUE val;
 
 	Check_Type(rb_entry, T_HASH);
 
-#define GET_ENTRY_VAL(v, t) \
-	rb_hash_aref(rb_entry, CSTR2SYM(v)); \
-	Check_Type(val, t);
-
-	val = GET_ENTRY_VAL("path", T_STRING);
+	val = rb_hash_aref(rb_entry, CSTR2SYM("path"));
+	Check_Type(val, T_STRING);
 	entry->path = StringValueCStr(val);
 
-	val = GET_ENTRY_VAL("oid", T_STRING);
-	rugged_exception_check(git_oid_fromstr(&entry->oid, StringValueCStr(val)));
-
-	val = GET_ENTRY_VAL("dev", T_FIXNUM);
-	entry->dev = FIX2INT(val);
-
-	val = GET_ENTRY_VAL("ino", T_FIXNUM);
-	entry->ino = FIX2INT(val);
-
-	val = GET_ENTRY_VAL("mode", T_FIXNUM);
-	entry->mode = FIX2INT(val);
-
-	val = GET_ENTRY_VAL("gid", T_FIXNUM);
-	entry->gid = FIX2INT(val);
+	val = rb_hash_aref(rb_entry, CSTR2SYM("oid"));
+	Check_Type(val, T_STRING);
+	rugged_exception_check(
+		git_oid_fromstr(&entry->oid, StringValueCStr(val))
+	);
+
+	entry->dev = default_entry_value(rb_entry, "dev");
+	entry->ino = default_entry_value(rb_entry, "ino");
+	entry->mode = default_entry_value(rb_entry, "mode");
+	entry->gid = default_entry_value(rb_entry, "gid");
+	entry->uid = default_entry_value(rb_entry, "uid");
+	entry->file_size = (git_off_t)default_entry_value(rb_entry, "file_size");
+
+	if ((val = rb_hash_aref(rb_entry, CSTR2SYM("mtime"))) != Qnil) {
+		if (!rb_obj_is_kind_of(val, rb_cTime))
+			rb_raise(rb_eTypeError, ":mtime must be a Time instance");
+
+		entry->mtime.seconds = NUM2INT(rb_funcall(val, rb_intern("to_i"), 0));
+		entry->mtime.nanoseconds = NUM2INT(rb_funcall(val, rb_intern("usec"), 0)) * 1000;
+	} else {
+		entry->mtime.seconds = entry->mtime.nanoseconds = 0;
+	}
 
-	val = GET_ENTRY_VAL("uid", T_FIXNUM);
-	entry->uid = FIX2INT(val);
+	if ((val = rb_hash_aref(rb_entry, CSTR2SYM("ctime"))) != Qnil) {
+		if (!rb_obj_is_kind_of(val, rb_cTime))
+			rb_raise(rb_eTypeError, ":ctime must be a Time instance");
 
-	val = GET_ENTRY_VAL("file_size", T_FIXNUM);
-	entry->file_size = FIX2INT(val);
+		entry->ctime.seconds = NUM2INT(rb_funcall(val, rb_intern("to_i"), 0));
+		entry->ctime.nanoseconds = NUM2INT(rb_funcall(val, rb_intern("usec"), 0)) * 1000;
+	} else {
+		entry->ctime.seconds = entry->ctime.nanoseconds = 0;
+	}
 
 	entry->flags = 0x0;
 	entry->flags_extended = 0x0;
@@ -350,57 +317,31 @@ static void rb_git_indexentry_toC(git_index_entry *entry, VALUE rb_entry)
 		entry->flags &= ~GIT_IDXENTRY_VALID;
 		if (rugged_parse_bool(val))
 			entry->flags |= GIT_IDXENTRY_VALID;
-	} /* TODO: always valid by default? */
-
-	val = rb_hash_aref(rb_entry, CSTR2SYM("mtime"));
-	if (!rb_obj_is_kind_of(val, rb_cTime))
-		rb_raise(rb_eTypeError, ":mtime must be a Time instance");
-	entry->mtime.seconds = NUM2INT(rb_funcall(val, rb_intern("to_i"), 0));
-	entry->mtime.nanoseconds = NUM2INT(rb_funcall(val, rb_intern("usec"), 0)) * 1000;
-
-	val = rb_hash_aref(rb_entry, CSTR2SYM("ctime"));
-	if (!rb_obj_is_kind_of(val, rb_cTime))
-		rb_raise(rb_eTypeError, ":ctime must be a Time instance");
-	entry->ctime.seconds = NUM2INT(rb_funcall(val, rb_intern("to_i"), 0));
-	entry->ctime.nanoseconds = NUM2INT(rb_funcall(val, rb_intern("usec"), 0)) * 1000;
-
-#undef GET_ENTRY_VAL
-}
-
-VALUE rb_git_indexer(VALUE self, VALUE rb_packfile_path)
-{
-	int error;
-	git_indexer *indexer;
-	VALUE rb_oid;
-
-	Check_Type(rb_packfile_path, T_STRING);
-
-	error = git_indexer_new(&indexer, StringValueCStr(rb_packfile_path));
-	rugged_exception_check(error);
-
-	error = git_indexer_run(indexer, NULL);
-	rugged_exception_check(error);
-
-	error = git_indexer_write(indexer);
-	rugged_exception_check(error);
-
-	rb_oid = rugged_create_oid(git_indexer_hash(indexer));
-
-	git_indexer_free(indexer);
-	return rb_oid;
+	} else {
+		entry->flags |= GIT_IDXENTRY_VALID;
+	}
 }
 
-VALUE rb_git_index_writetree(VALUE self)
+static VALUE rb_git_index_writetree(int argc, VALUE *argv, VALUE self)
 {
 	git_index *index;
 	git_oid tree_oid;
 	int error;
+	VALUE rb_repo;
 
 	Data_Get_Struct(self, git_index, index);
 
-	error = git_tree_create_fromindex(&tree_oid, index);
-	rugged_exception_check(error);
+	if (rb_scan_args(argc, argv, "01", &rb_repo) == 1) {
+		git_repository *repo = NULL;
+		rugged_check_repo(rb_repo);
+		Data_Get_Struct(rb_repo, git_repository, repo);
+		error = git_index_write_tree_to(&tree_oid, index, repo);
+	}
+	else {
+		error = git_index_write_tree(&tree_oid, index);
+	}
 
+	rugged_exception_check(error);
 	return rugged_create_oid(&tree_oid);
 }
 
@@ -413,7 +354,7 @@ VALUE rb_git_index_writetree(VALUE self)
  *      Further index operations (+add+, +update+, +remove+, etc) will
  *      be considered changes on top of +tree+.
  */
-VALUE rb_git_index_readtree(VALUE self, VALUE rb_tree)
+static VALUE rb_git_index_readtree(VALUE self, VALUE rb_tree)
 {
 	git_index *index;
 	git_tree *tree;
@@ -422,7 +363,7 @@ VALUE rb_git_index_readtree(VALUE self, VALUE rb_tree)
 	Data_Get_Struct(self, git_index, index);
 	Data_Get_Struct(rb_tree, git_tree, tree);
 
-	error = git_index_read_tree(index, tree, NULL);
+	error = git_index_read_tree(index, tree);
 	rugged_exception_check(error);
 
 	return Qnil;
@@ -431,34 +372,28 @@ VALUE rb_git_index_readtree(VALUE self, VALUE rb_tree)
 void Init_rugged_index()
 {
 	/*
-	 * Index 
+	 * Index
 	 */
 	rb_cRuggedIndex = rb_define_class_under(rb_mRugged, "Index", rb_cObject);
-	rb_define_singleton_method(rb_cRuggedIndex, "new", rb_git_index_new, 1);
+	rb_define_singleton_method(rb_cRuggedIndex, "new", rb_git_index_new, -1);
 
 	rb_define_method(rb_cRuggedIndex, "count", rb_git_index_count, 0);
-	rb_define_method(rb_cRuggedIndex, "count_unmerged", rb_git_index_count_unmerged, 0);
 	rb_define_method(rb_cRuggedIndex, "reload", rb_git_index_read, 0);
 	rb_define_method(rb_cRuggedIndex, "clear", rb_git_index_clear, 0);
 	rb_define_method(rb_cRuggedIndex, "write", rb_git_index_write, 0);
-	rb_define_method(rb_cRuggedIndex, "uniq!", rb_git_index_uniq, 0);
-	rb_define_method(rb_cRuggedIndex, "get_entry", rb_git_index_get, 1);
-	rb_define_method(rb_cRuggedIndex, "get_unmerged", rb_git_index_get_unmerged, 1);
-	rb_define_method(rb_cRuggedIndex, "[]", rb_git_index_get, 1);
+	rb_define_method(rb_cRuggedIndex, "get", rb_git_index_get, -1);
+	rb_define_method(rb_cRuggedIndex, "[]", rb_git_index_get, -1);
 	rb_define_method(rb_cRuggedIndex, "each", rb_git_index_each, 0);
 
-	rb_define_method(rb_cRuggedIndex, "add", rb_git_index_add, -1);
-	rb_define_method(rb_cRuggedIndex, "update", rb_git_index_add, -1);
+	rb_define_method(rb_cRuggedIndex, "add", rb_git_index_add, 1);
+	rb_define_method(rb_cRuggedIndex, "update", rb_git_index_add, 1);
+	rb_define_method(rb_cRuggedIndex, "<<", rb_git_index_add, 1);
 
-	rb_define_method(rb_cRuggedIndex, "append", rb_git_index_append, -1);
-	rb_define_method(rb_cRuggedIndex, "<<", rb_git_index_append, -1);
+	rb_define_method(rb_cRuggedIndex, "remove", rb_git_index_remove, -1);
 
-	rb_define_method(rb_cRuggedIndex, "remove", rb_git_index_remove, 1);
-	rb_define_method(rb_cRuggedIndex, "write_tree", rb_git_index_writetree, 0);
+	rb_define_method(rb_cRuggedIndex, "write_tree", rb_git_index_writetree, -1);
 	rb_define_method(rb_cRuggedIndex, "read_tree", rb_git_index_readtree, 1);
 
-	rb_define_singleton_method(rb_cRuggedIndex, "index_pack", rb_git_indexer, 1);
-
 	rb_const_set(rb_cRuggedIndex, rb_intern("ENTRY_FLAGS_STAGE"), INT2FIX(GIT_IDXENTRY_STAGEMASK));
 	rb_const_set(rb_cRuggedIndex, rb_intern("ENTRY_FLAGS_STAGE_SHIFT"), INT2FIX(GIT_IDXENTRY_STAGESHIFT));
 	rb_const_set(rb_cRuggedIndex, rb_intern("ENTRY_FLAGS_VALID"), INT2FIX(GIT_IDXENTRY_VALID));