rugged 0.28.4.1 → 1.0.1

data/ext/rugged/rugged_note.c

@@ -10,6 +10,8 @@
 extern VALUE rb_cRuggedRepo;
 extern VALUE rb_cRuggedObject;
 
+extern const rb_data_type_t rugged_object_type;
+
 static VALUE rugged_git_note_message(const git_note *note)
 {
 	const char *message;
@@ -59,7 +61,7 @@ static VALUE rb_git_note_lookup(int argc, VALUE *argv, VALUE self)
 		notes_ref = StringValueCStr(rb_notes_ref);
 	}
 
-	Data_Get_Struct(self, git_object, object);
+	TypedData_Get_Struct(self, git_object, &rugged_object_type, object);
 
 	owner = rugged_owner(self);
 	Data_Get_Struct(owner, git_repository, repo);
@@ -124,7 +126,7 @@ static VALUE rb_git_note_create(VALUE self, VALUE rb_data)
 
 	Check_Type(rb_data, T_HASH);
 
-	Data_Get_Struct(self, git_object, target);
+	TypedData_Get_Struct(self, git_object, &rugged_object_type, target);
 
 	owner = rugged_owner(self);
 	Data_Get_Struct(owner, git_repository, repo);
@@ -207,7 +209,7 @@ static VALUE rb_git_note_remove(int argc, VALUE *argv, VALUE self)
 	VALUE rb_committer = Qnil;
 	VALUE owner;
 
-	Data_Get_Struct(self, git_object, target);
+	TypedData_Get_Struct(self, git_object, &rugged_object_type, target);
 
 	owner = rugged_owner(self);
 	Data_Get_Struct(owner, git_repository, repo);

data/ext/rugged/rugged_object.c

@@ -16,6 +16,8 @@ extern VALUE rb_cRuggedRepo;
 
 VALUE rb_cRuggedObject;
 
+const rb_data_type_t rugged_object_type;
+
 git_otype rugged_otype_get(VALUE self)
 {
 	git_otype type = GIT_OBJ_BAD;
@@ -74,7 +76,7 @@ int rugged_oid_get(git_oid *oid, git_repository *repo, VALUE p)
 	int error;
 
 	if (rb_obj_is_kind_of(p, rb_cRuggedObject)) {
-		Data_Get_Struct(p, git_object, object);
+		TypedData_Get_Struct(p, git_object, &rugged_object_type, object);
 		git_oid_cpy(oid, git_object_id(object));
 	} else {
 		Check_Type(p, T_STRING);
@@ -100,7 +102,7 @@ git_object *rugged_object_get(git_repository *repo, VALUE object_value, git_otyp
 
 	if (rb_obj_is_kind_of(object_value, rb_cRuggedObject)) {
 		git_object *owned_obj = NULL;
-		Data_Get_Struct(object_value, git_object, owned_obj);
+		TypedData_Get_Struct(object_value, git_object, &rugged_object_type, owned_obj);
 		git_object_dup(&object, owned_obj);
 	} else {
 		int error;
@@ -132,11 +134,56 @@ git_object *rugged_object_get(git_repository *repo, VALUE object_value, git_otyp
 	return object;
 }
 
-static void rb_git_object__free(git_object *object)
+static void rb_git_object__free(void *data)
 {
+	git_object *object = (git_object *) data;
 	git_object_free(object);
 }
 
+static size_t rb_git_object__size(const void *data)
+{
+	git_object *object = (git_object *) data;
+	size_t size = 0;
+
+	/*
+	 * We cannot always be accurate cheaply, but we can give some numbers
+	 * which are closer than zero by taking an average/guessed size.
+	 */
+	switch (git_object_type(object)) {
+	case GIT_OBJ_BLOB:
+	{
+		git_blob *blob = (git_blob *) object;
+		size = git_blob_rawsize(blob);
+		break;
+	}
+	case GIT_OBJ_TREE:
+	{
+		git_tree *tree = (git_tree *) object;
+		size = git_tree_entrycount(tree) * 64;
+		break;
+	}
+	case GIT_OBJ_COMMIT:
+	case GIT_OBJ_TAG:
+		size = 256;
+		break;
+	default:
+		break;
+	}
+
+	return size;
+}
+
+const rb_data_type_t rugged_object_type = {
+	.wrap_struct_name = "Rugged::Object",
+	.function = {
+		.dmark = NULL,
+		.dfree = rb_git_object__free,
+		.dsize = rb_git_object__size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE rugged_object_new(VALUE owner, git_object *object)
 {
 	VALUE klass, rb_object;
@@ -164,7 +211,7 @@ VALUE rugged_object_new(VALUE owner, git_object *object)
 			return Qnil; /* never reached */
 	}
 
-	rb_object = Data_Wrap_Struct(klass, NULL, &rb_git_object__free, object);
+	rb_object = TypedData_Wrap_Struct(klass, &rugged_object_type, object);
 	rugged_set_owner(rb_object, owner);
 	return rb_object;
 }
@@ -307,8 +354,8 @@ static VALUE rb_git_object_equal(VALUE self, VALUE other)
 	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);
+	TypedData_Get_Struct(self, git_object, &rugged_object_type, a);
+	TypedData_Get_Struct(other, git_object, &rugged_object_type, b);
 
 	return git_oid_cmp(git_object_id(a), git_object_id(b)) == 0 ? Qtrue : Qfalse;
 }
@@ -321,7 +368,7 @@ static VALUE rb_git_object_equal(VALUE self, VALUE other)
 static VALUE rb_git_object_oid_GET(VALUE self)
 {
 	git_object *object;
-	Data_Get_Struct(self, git_object, object);
+	TypedData_Get_Struct(self, git_object, &rugged_object_type, object);
 	return rugged_create_oid(git_object_id(object));
 }
 
@@ -333,7 +380,7 @@ static VALUE rb_git_object_oid_GET(VALUE self)
 static VALUE rb_git_object_type_GET(VALUE self)
 {
 	git_object *object;
-	Data_Get_Struct(self, git_object, object);
+	TypedData_Get_Struct(self, git_object, &rugged_object_type, object);
 
 	return rugged_otype_new(git_object_type(object));
 }
@@ -346,14 +393,14 @@ static VALUE rb_git_object_type_GET(VALUE self)
 static VALUE rb_git_object_read_raw(VALUE self)
 {
 	git_object *object;
-	Data_Get_Struct(self, git_object, object);
+	TypedData_Get_Struct(self, git_object, &rugged_object_type, 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_cRuggedObject = rb_define_class_under(rb_mRugged, "Object", rb_cData);
 	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);

data/ext/rugged/rugged_rebase.c

@@ -15,6 +15,8 @@ extern VALUE rb_cRuggedReference;
 
 VALUE rb_cRuggedRebase;
 
+extern const rb_data_type_t rugged_object_type;
+
 static VALUE rebase_operation_type(git_rebase_operation *operation);
 
 static void parse_rebase_options(git_rebase_options *ret, VALUE rb_options)
@@ -70,7 +72,7 @@ static void get_annotated_commit(git_annotated_commit **annotated_commit, VALUE
 		const git_commit * commit;
 		const git_oid * oid;
 
-		Data_Get_Struct(rb_value, git_commit, commit);
+		TypedData_Get_Struct(rb_value, git_commit, &rugged_object_type, commit);
 
 		oid = git_commit_id(commit);
 		error = git_annotated_commit_lookup(annotated_commit, repo, oid);

data/ext/rugged/rugged_remote.c

@@ -157,12 +157,6 @@ static int credentials_cb(
 	return payload->exception ? GIT_ERROR : GIT_OK;
 }
 
-#define CALLABLE_OR_RAISE(ret, name) \
-	do { \
-		if (!rb_respond_to(ret, rb_intern("call"))) \
-			rb_raise(rb_eArgError, "Expected a Proc or an object that responds to #call (:" name " )."); \
-	} while (0);
-
 void rugged_remote_init_callbacks_and_payload_from_options(
 	VALUE rb_options,
 	git_remote_callbacks *callbacks,
@@ -213,6 +207,18 @@ static void init_custom_headers(VALUE rb_options, git_strarray *custom_headers)
 	}
 }
 
+static void init_proxy_options(VALUE rb_options, git_proxy_options *proxy_options)
+{
+	if (NIL_P(rb_options)) return;
+
+	VALUE val = rb_hash_aref(rb_options, CSTR2SYM("proxy_url"));
+	if (!NIL_P(val)) {
+		Check_Type(val, T_STRING);
+		proxy_options->type = GIT_PROXY_SPECIFIED;
+		proxy_options->url = StringValueCStr(val);
+	}
+}
+
 static int parse_prune_type(VALUE rb_prune_type)
 {
 	if (rb_prune_type == Qtrue) {
@@ -289,11 +295,15 @@ static VALUE rugged_rhead_new(const git_remote_head *head)
  *
  *  :headers ::
  *    Extra HTTP headers to include with the request (only applies to http:// or https:// remotes)
+ *
+ *  :proxy_url ::
+ *    The url of an http proxy to use to access the remote repository.
  */
 static VALUE rb_git_remote_ls(int argc, VALUE *argv, VALUE self)
 {
 	git_remote *remote;
 	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+	git_proxy_options proxy_options = GIT_PROXY_OPTIONS_INIT;
 	git_strarray custom_headers = {0};
 	const git_remote_head **heads;
 
@@ -310,8 +320,9 @@ static VALUE rb_git_remote_ls(int argc, VALUE *argv, VALUE self)
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
 	init_custom_headers(rb_options, &custom_headers);
+	init_proxy_options(rb_options, &proxy_options);
 
-	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, &callbacks, NULL, &custom_headers)) ||
+	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, &callbacks, &proxy_options, &custom_headers)) ||
 	    (error = git_remote_ls(&heads, &heads_len, remote)))
 		goto cleanup;
 
@@ -480,6 +491,9 @@ static VALUE rb_git_remote_push_refspecs(VALUE self)
  *  :headers ::
  *    Extra HTTP headers to include with the request (only applies to http:// or https:// remotes)
  *
+ *  :proxy_url ::
+ *    The url of an http proxy to use to access the remote repository.
+ *
  *  Example:
  *
  *    remote = repo.remotes["origin"]
@@ -490,6 +504,7 @@ static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
 {
 	git_remote *remote;
 	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+	git_proxy_options proxy_options = GIT_PROXY_OPTIONS_INIT;
 	git_strarray custom_headers = {0};
 	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
 	VALUE rb_direction, rb_options;
@@ -510,8 +525,9 @@ static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
 	init_custom_headers(rb_options, &custom_headers);
+	init_proxy_options(rb_options, &proxy_options);
 
-	error = git_remote_connect(remote, direction, &callbacks, NULL, &custom_headers);
+	error = git_remote_connect(remote, direction, &callbacks, &proxy_options, &custom_headers);
 	git_remote_disconnect(remote);
 
 	xfree(custom_headers.strings);
@@ -569,6 +585,9 @@ static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
  *    Specifies the prune mode for the fetch. +true+ remove any remote-tracking references that
  *    no longer exist, +false+ do not prune, +nil+ use configured settings Defaults to "nil".
  *
+ *  :proxy_url ::
+ *    The url of an http proxy to use to access the remote repository.
+ *
  *  Example:
  *
  *    remote = Rugged::Remote.lookup(@repo, 'origin')
@@ -599,6 +618,7 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &opts.callbacks, &payload);
 	init_custom_headers(rb_options, &opts.custom_headers);
+	init_proxy_options(rb_options, &opts.proxy_opts);
 
 	if (!NIL_P(rb_options)) {
 		VALUE rb_prune_type;
@@ -660,6 +680,9 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
  *  :headers ::
  *    Extra HTTP headers to include with the push (only applies to http:// or https:// remotes)
  *
+ *  :proxy_url ::
+ *    The url of an http proxy to use to access the remote repository.
+ *
  *  Example:
  *
  *    remote = Rugged::Remote.lookup(@repo, 'origin')
@@ -685,6 +708,7 @@ static VALUE rb_git_remote_push(int argc, VALUE *argv, VALUE self)
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &opts.callbacks, &payload);
 	init_custom_headers(rb_options, &opts.custom_headers);
+	init_proxy_options(rb_options, &opts.proxy_opts);
 
 	error = git_remote_push(remote, &refspecs, &opts);
 

data/ext/rugged/rugged_repo.c

@@ -10,6 +10,7 @@
 #include <git2/sys/odb_backend.h>
 #include <git2/sys/refdb_backend.h>
 #include <git2/refs.h>
+#include <git2/apply.h>
 
 extern VALUE rb_mRugged;
 extern VALUE rb_eRuggedError;
@@ -18,6 +19,7 @@ extern VALUE rb_cRuggedConfig;
 extern VALUE rb_cRuggedBackend;
 extern VALUE rb_cRuggedRemote;
 extern VALUE rb_cRuggedCommit;
+extern VALUE rb_cRuggedDiff;
 extern VALUE rb_cRuggedTag;
 extern VALUE rb_cRuggedTree;
 extern VALUE rb_cRuggedReference;
@@ -32,6 +34,9 @@ VALUE rb_cRuggedOdbObject;
 
 static ID id_call;
 
+extern const rb_data_type_t rugged_object_type;
+static const rb_data_type_t rugged_odb_object_type;
+
 /*
  *  call-seq:
  *    odb_obj.oid -> hex_oid
@@ -44,7 +49,7 @@ static ID id_call;
 static VALUE rb_git_odbobj_oid(VALUE self)
 {
 	git_odb_object *obj;
-	Data_Get_Struct(self, git_odb_object, obj);
+	TypedData_Get_Struct(self, git_odb_object, &rugged_odb_object_type, obj);
 	return rugged_create_oid(git_odb_object_id(obj));
 }
 
@@ -62,7 +67,7 @@ static VALUE rb_git_odbobj_oid(VALUE self)
 static VALUE rb_git_odbobj_data(VALUE self)
 {
 	git_odb_object *obj;
-	Data_Get_Struct(self, git_odb_object, obj);
+	TypedData_Get_Struct(self, git_odb_object, &rugged_odb_object_type, obj);
 	return rb_str_new(git_odb_object_data(obj), git_odb_object_size(obj));
 }
 
@@ -78,7 +83,7 @@ static VALUE rb_git_odbobj_data(VALUE self)
 static VALUE rb_git_odbobj_size(VALUE self)
 {
 	git_odb_object *obj;
-	Data_Get_Struct(self, git_odb_object, obj);
+	TypedData_Get_Struct(self, git_odb_object, &rugged_odb_object_type, obj);
 	return INT2FIX(git_odb_object_size(obj));
 }
 
@@ -94,7 +99,7 @@ static VALUE rb_git_odbobj_size(VALUE self)
 static VALUE rb_git_odbobj_type(VALUE self)
 {
 	git_odb_object *obj;
-	Data_Get_Struct(self, git_odb_object, obj);
+	TypedData_Get_Struct(self, git_odb_object, &rugged_odb_object_type, obj);
 	return rugged_otype_new(git_odb_object_type(obj));
 }
 
@@ -103,6 +108,24 @@ void rb_git__odbobj_free(void *obj)
 	git_odb_object_free((git_odb_object *)obj);
 }
 
+static size_t rb_git__odbobj_size(const void *obj)
+{
+	return git_odb_object_size((git_odb_object *)obj);
+}
+
+static const rb_data_type_t rugged_odb_object_type = {
+	.wrap_struct_name = "Rugged::OdbObject",
+	.function = {
+		.dmark = NULL,
+		.dfree = rb_git__odbobj_free,
+		.dsize = rb_git__odbobj_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+
+
 VALUE rugged_raw_read(git_repository *repo, const git_oid *oid)
 {
 	git_odb *odb;
@@ -117,7 +140,7 @@ VALUE rugged_raw_read(git_repository *repo, const git_oid *oid)
 	git_odb_free(odb);
 	rugged_exception_check(error);
 
-	return Data_Wrap_Struct(rb_cRuggedOdbObject, NULL, rb_git__odbobj_free, obj);
+	return TypedData_Wrap_Struct(rb_cRuggedOdbObject, &rugged_odb_object_type, obj);
 }
 
 void rb_git_repo__free(git_repository *repo)
@@ -396,6 +419,98 @@ static VALUE rb_git_repo_init_at(int argc, VALUE *argv, VALUE klass)
 	return rugged_repo_new(klass, repo);
 }
 
+static int apply_cb_result(int exception, VALUE result)
+{
+	if (exception || result == Qnil) {
+		return GIT_EAPPLYFAIL;
+	} else {
+		if (RTEST(result)) {
+			return 0;
+		} else {
+			return 1;
+		}
+	}
+}
+
+static int apply_delta_cb(const git_diff_delta *delta, void *data)
+{
+	struct rugged_apply_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(2);
+	VALUE result;
+
+	if (NIL_P(payload->delta_cb))
+		return 0;
+
+	VALUE rb_delta = rugged_diff_delta_new(Qnil, delta);
+
+	rb_ary_push(args, payload->delta_cb);
+	rb_ary_push(args, rb_delta);
+
+	result = rb_protect(rugged__block_yield_splat, args, &payload->exception);
+
+	return apply_cb_result(payload->exception, result);
+}
+
+static int apply_hunk_cb(const git_diff_hunk *hunk, void *data)
+{
+	struct rugged_apply_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(2);
+	VALUE result;
+
+	if (NIL_P(payload->hunk_cb))
+		return 0;
+
+	VALUE rb_hunk = rugged_diff_hunk_new(Qnil, 0, hunk, 0);
+
+	rb_ary_push(args, payload->hunk_cb);
+	rb_ary_push(args, rb_hunk);
+
+	result = rb_protect(rugged__block_yield_splat, args, &payload->exception);
+
+	return apply_cb_result(payload->exception, result);
+}
+
+static void rugged_parse_apply_options(git_apply_options *opts, git_apply_location_t *location, VALUE rb_options, struct rugged_apply_cb_payload *payload)
+{
+	if (!NIL_P(rb_options)) {
+		VALUE rb_value;
+		Check_Type(rb_options, T_HASH);
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("location"));
+		if (!NIL_P(rb_value)) {
+			ID id_location;
+
+			Check_Type(rb_value, T_SYMBOL);
+			id_location = SYM2ID(rb_value);
+
+			if (id_location == rb_intern("both")) {
+				*location = GIT_APPLY_LOCATION_BOTH;
+			} else if (id_location == rb_intern("index")) {
+				*location = GIT_APPLY_LOCATION_INDEX;
+			} else if (id_location == rb_intern("workdir")) {
+				*location = GIT_APPLY_LOCATION_WORKDIR;
+			} else {
+				rb_raise(rb_eTypeError,
+					"Invalid location. Expected `:both`, `:index`, or `:workdir`");
+			}
+		}
+
+		opts->payload = payload;
+
+		payload->delta_cb = rb_hash_aref(rb_options, CSTR2SYM("delta_callback"));
+		if (!NIL_P(payload->delta_cb)) {
+			CALLABLE_OR_RAISE(payload->delta_cb, "delta_callback");
+			opts->delta_cb = apply_delta_cb;
+		}
+
+		payload->hunk_cb = rb_hash_aref(rb_options, CSTR2SYM("hunk_callback"));
+		if (!NIL_P(payload->hunk_cb)) {
+			CALLABLE_OR_RAISE(payload->hunk_cb, "hunk_callback");
+			opts->hunk_cb = apply_hunk_cb;
+		}
+	}
+}
+
 static void parse_clone_options(git_clone_options *ret, VALUE rb_options, struct rugged_remote_cb_payload *remote_payload)
 {
 	VALUE val;
@@ -413,6 +528,13 @@ static void parse_clone_options(git_clone_options *ret, VALUE rb_options, struct
 		ret->checkout_branch = StringValueCStr(val);
 	}
 
+	val = rb_hash_aref(rb_options, CSTR2SYM("proxy_url"));
+	if (!NIL_P(val)) {
+		Check_Type(val, T_STRING);
+		ret->fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED;
+		ret->fetch_opts.proxy_opts.url = StringValueCStr(val);
+	}
+
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &ret->fetch_opts.callbacks, remote_payload);
 }
 
@@ -437,6 +559,9 @@ static void parse_clone_options(git_clone_options *ret, VALUE rb_options, struct
  *  :ignore_cert_errors ::
  *    If set to +true+, errors while validating the remote's host certificate will be ignored.
  *
+ *  :proxy_url ::
+ *    The url of an http proxy to use to access the remote repository.
+ *
  *  :credentials ::
  *    The credentials to use for the clone operation. Can be either an instance of one
  *    of the Rugged::Credentials types, or a proc returning one of the former.
@@ -788,7 +913,7 @@ static VALUE rb_git_repo_merge_analysis(int argc, VALUE *argv, VALUE self)
 		rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
 	}
 
-	Data_Get_Struct(rb_their_commit, git_commit, their_commit);
+	TypedData_Get_Struct(rb_their_commit, git_commit, &rugged_object_type, their_commit);
 
 	error = git_annotated_commit_lookup(&annotated_commit, repo, git_commit_id(their_commit));
 	rugged_exception_check(error);
@@ -856,8 +981,8 @@ static VALUE rb_git_repo_revert_commit(int argc, VALUE *argv, VALUE self)
 	}
 
 	Data_Get_Struct(self, git_repository, repo);
-	Data_Get_Struct(rb_revert_commit, git_commit, revert_commit);
-	Data_Get_Struct(rb_our_commit, git_commit, our_commit);
+	TypedData_Get_Struct(rb_revert_commit, git_commit, &rugged_object_type, revert_commit);
+	TypedData_Get_Struct(rb_our_commit, git_commit, &rugged_object_type, our_commit);
 
 	error = git_revert_commit(&index, repo, revert_commit, our_commit, mainline, &opts);
 	if (error == GIT_EMERGECONFLICT)
@@ -868,6 +993,69 @@ static VALUE rb_git_repo_revert_commit(int argc, VALUE *argv, VALUE self)
 	return rugged_index_new(rb_cRuggedIndex, self, index);
 }
 
+/*
+ *  call-seq:
+ *    repo.apply(diff, options = {}) -> true or false
+ *
+ *	Applies the given diff to the repository.
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :location ::
+ *    Whether to apply the changes to the workdir (default for non-bare),
+ *    the index (default for bare) or both. Valid values: +:index+, +:workdir+,
+ *    +:both+.
+ *
+ *  :delta_callback ::
+ *    While applying the patch, this callback will be executed per delta (file).
+ *    The current +delta+ will be passed to the block. The block's return value
+ *    determines further behavior. When the block evaluates to:
+ *       - +true+: the hunk will be applied and the apply process will continue.
+ *       - +false+: the hunk will be skipped, but the apply process continues.
+ *       - +nil+: the hunk is not applied, and the apply process is aborted.
+ *
+ *  :hunk_callback ::
+ *    While applying the patch, this callback will be executed per hunk.
+ *    The current +hunk+ will be passed to the block. The block's return value
+ *    determines further behavior, as per +:delta_callback+.
+ *
+ */
+static VALUE rb_git_repo_apply(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_diff, rb_options;
+	git_diff *diff;
+	git_repository *repo;
+	git_apply_options opts = GIT_APPLY_OPTIONS_INIT;
+	git_apply_location_t location;
+	struct rugged_apply_cb_payload payload = { Qnil, Qnil, 0 };
+	int error;
+
+	Data_Get_Struct(self, git_repository, repo);
+	if (git_repository_is_bare(repo)) {
+		location = GIT_APPLY_LOCATION_INDEX;
+	} else {
+		location = GIT_APPLY_LOCATION_WORKDIR;
+	}
+
+	rb_scan_args(argc, argv, "11", &rb_diff, &rb_options);
+
+	if (!rb_obj_is_kind_of(rb_diff, rb_cRuggedDiff)) {
+		rb_raise(rb_eArgError, "Expected a Rugged::Diff.");
+	}
+
+	if (!NIL_P(rb_options)) {
+		Check_Type(rb_options, T_HASH);
+		rugged_parse_apply_options(&opts, &location, rb_options, &payload);
+	}
+
+	Data_Get_Struct(rb_diff, git_diff, diff);
+
+	error = git_apply(repo, diff, location, &opts);
+
+	rugged_exception_check(error);
+
+	return Qtrue;
+}
+
 /*
  *  call-seq:
  *    repo.merge_commits(our_commit, their_commit, options = {}) -> index
@@ -911,8 +1099,8 @@ static VALUE rb_git_repo_merge_commits(int argc, VALUE *argv, VALUE self)
 	}
 
 	Data_Get_Struct(self, git_repository, repo);
-	Data_Get_Struct(rb_our_commit, git_commit, our_commit);
-	Data_Get_Struct(rb_their_commit, git_commit, their_commit);
+	TypedData_Get_Struct(rb_our_commit, git_commit, &rugged_object_type, our_commit);
+	TypedData_Get_Struct(rb_their_commit, git_commit, &rugged_object_type, their_commit);
 
 	error = git_merge_commits(&index, repo, our_commit, their_commit, &opts);
 	if (error == GIT_EMERGECONFLICT)
@@ -1518,7 +1706,7 @@ static VALUE rb_git_repo_file_status(VALUE self, VALUE rb_path)
 
 static VALUE rb_git_repo_file_each_status(VALUE self)
 {
-	int error, exception;
+	int error, exception = 0;
 	size_t i, nentries;
 	git_repository *repo;
 	git_status_list *list;
@@ -2026,7 +2214,7 @@ void rugged_parse_checkout_options(git_checkout_options *opts, VALUE rb_options)
 	rb_value = rb_hash_aref(rb_options, CSTR2SYM("baseline"));
 	if (!NIL_P(rb_value)) {
 		if (rb_obj_is_kind_of(rb_value, rb_cRuggedTree)) {
-			Data_Get_Struct(rb_value, git_tree, opts->baseline);
+			TypedData_Get_Struct(rb_value, git_tree, &rugged_object_type, opts->baseline);
 		} else {
 			rb_raise(rb_eTypeError, "Expected a Rugged::Tree.");
 		}
@@ -2190,7 +2378,7 @@ static VALUE rb_git_checkout_tree(int argc, VALUE *argv, VALUE self)
 	}
 
 	Data_Get_Struct(self, git_repository, repo);
-	Data_Get_Struct(rb_treeish, git_object, treeish);
+	TypedData_Get_Struct(rb_treeish, git_object, &rugged_object_type, treeish);
 
 	rugged_parse_checkout_options(&opts, rb_options);
 
@@ -2488,7 +2676,7 @@ static VALUE rb_git_repo_cherrypick(int argc, VALUE *argv, VALUE self)
 	}
 
 	Data_Get_Struct(self, git_repository, repo);
-	Data_Get_Struct(rb_commit, git_commit, commit);
+	TypedData_Get_Struct(rb_commit, git_commit, &rugged_object_type, commit);
 
 	rugged_parse_cherrypick_options(&opts, rb_options);
 
@@ -2541,8 +2729,8 @@ static VALUE rb_git_repo_cherrypick_commit(int argc, VALUE *argv, VALUE self)
 	}
 
 	Data_Get_Struct(self, git_repository, repo);
-	Data_Get_Struct(rb_commit, git_commit, commit);
-	Data_Get_Struct(rb_our_commit, git_commit, our_commit);
+	TypedData_Get_Struct(rb_commit, git_commit, &rugged_object_type, commit);
+	TypedData_Get_Struct(rb_our_commit, git_commit, &rugged_object_type, our_commit);
 
 	rugged_parse_merge_options(&opts, rb_options);
 
@@ -2553,6 +2741,29 @@ static VALUE rb_git_repo_cherrypick_commit(int argc, VALUE *argv, VALUE self)
 	return rugged_index_new(rb_cRuggedIndex, self, index);
 }
 
+/*
+ *  call-seq: repo.diff_from_buffer(buffer) -> Rugged::Diff object
+ *  
+ *  Where +buffer+ is a +String+.
+ *  Returns A Rugged::Diff object
+ */
+static VALUE rb_git_diff_from_buffer(VALUE self, VALUE rb_buffer)
+{
+	git_diff *diff = NULL;
+	const char *buffer;
+	size_t len;
+	int error;
+
+	Check_Type(rb_buffer, T_STRING);
+	buffer = RSTRING_PTR(rb_buffer);
+	len = RSTRING_LEN(rb_buffer);
+
+	error = git_diff_from_buffer(&diff, buffer, len);
+	rugged_exception_check(error);
+
+	return rugged_diff_new(rb_cRuggedDiff, self, diff);
+}
+
 void Init_rugged_repo(void)
 {
 	id_call = rb_intern("call");
@@ -2608,7 +2819,11 @@ void Init_rugged_repo(void)
 	rb_define_method(rb_cRuggedRepo, "merge_analysis", rb_git_repo_merge_analysis, -1);
 	rb_define_method(rb_cRuggedRepo, "merge_commits", rb_git_repo_merge_commits, -1);
 
+	rb_define_method(rb_cRuggedRepo, "apply", rb_git_repo_apply, -1);
+
 	rb_define_method(rb_cRuggedRepo, "revert_commit", rb_git_repo_revert_commit, -1);
+	
+	rb_define_method(rb_cRuggedRepo, "diff_from_buffer", rb_git_diff_from_buffer, 1);
 
 	rb_define_method(rb_cRuggedRepo, "path_ignored?", rb_git_repo_is_path_ignored, 1);
 
@@ -2630,7 +2845,7 @@ void Init_rugged_repo(void)
 	rb_define_method(rb_cRuggedRepo, "cherrypick_commit", rb_git_repo_cherrypick_commit, -1);
 	rb_define_method(rb_cRuggedRepo, "fetch_attributes", rb_git_repo_attributes, -1);
 
-	rb_cRuggedOdbObject = rb_define_class_under(rb_mRugged, "OdbObject", rb_cObject);
+	rb_cRuggedOdbObject = rb_define_class_under(rb_mRugged, "OdbObject", rb_cData);
 	rb_define_method(rb_cRuggedOdbObject, "data",  rb_git_odbobj_data,  0);
 	rb_define_method(rb_cRuggedOdbObject, "len",  rb_git_odbobj_size,  0);
 	rb_define_method(rb_cRuggedOdbObject, "type",  rb_git_odbobj_type,  0);