rugged 1.9.0 → 1.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35b9bacf8b8490fe35d015f3a47ba27bfa63105f4e6657c2fdb77f99181e378b
-  data.tar.gz: 5d229542f5c4f156bd0b4c5add9730314e7a003c923d712d415731efe85d9a49
+  metadata.gz: ac3cbe7a9ea4030190d35d29db06a489ec5b6e6622e5a12fbf03c14a990baa2d
+  data.tar.gz: 6bfbf05eca385efc69ddc30f7bd892f302be1d0cd63e2ed09e007db478f7350e
 SHA512:
-  metadata.gz: 3af4216e9c917c87757c9c387a01a10d2173e00a3f9b834eb8a429c252fafc32a0a211f905ea74168bb8c46e6c95434b1eaa50c41feba3388ddfd7446ac9e162
-  data.tar.gz: 61c7da1b73112564d53e78a61de842de5d12a93515317d52e0b22c95f5e9312ca2aef3443eeb0e482dcf4208a86b60f9f831cf525948b49031ac7af28f6b2557
+  metadata.gz: 983ba1468a4066f98fbb0111037aa94ed23a3ff70c73f8b3e2c3e0a1229aa181f06f84bfeacb2f7ef16b3ede1433154f8729e024f1facc98ac1e99e1945aa62a
+  data.tar.gz: 70a96d4099de21a1e61e19a78ecb015d13e22d5b794145dcad485c555574c839052ffe015f818d62caf73a435d1d284c3649982a91c8c8d585ac07d496f89d71

data/ext/rugged/extconf.rb

@@ -71,12 +71,12 @@ if arg_config("--use-system-libraries", !!ENV['RUGGED_USE_SYSTEM_LIBRARIES'])
   major = minor = nil
 
   File.readlines(File.join(LIBGIT2_DIR, "include", "git2", "version.h")).each do |line|
-    if !major && (matches = line.match(/^#define LIBGIT2_VER_MAJOR\s+([0-9]+)$/))
+    if !major && (matches = line.match(/^#define LIBGIT2_VERSION_MAJOR\s+([0-9]+)$/))
       major = matches[1]
       next
     end
 
-    if !minor && (matches = line.match(/^#define LIBGIT2_VER_MINOR\s+([0-9]+)$/))
+    if !minor && (matches = line.match(/^#define LIBGIT2_VERSION_MINOR\s+([0-9]+)$/))
       minor = matches[1]
       next
     end
@@ -85,9 +85,9 @@ if arg_config("--use-system-libraries", !!ENV['RUGGED_USE_SYSTEM_LIBRARIES'])
   end
 
   try_compile(<<-SRC) or abort "libgit2 version is not compatible, expected ~> #{major}.#{minor}.0"
-#include <git2/version.h>
+#include <git2.h>
 
-#if LIBGIT2_VER_MAJOR != #{major} || LIBGIT2_VER_MINOR != #{minor}
+#if LIBGIT2_VERSION_MAJOR != #{major} || LIBGIT2_VERSION_MINOR != #{minor}
 #error libgit2 version is not compatible
 #endif
   SRC

data/ext/rugged/rugged.c

@@ -336,6 +336,16 @@ static void cleanup_cb(void *unused)
 	git_libgit2_shutdown();
 }
 
+static const rb_data_type_t rugged_shutdown_hook_type = {
+	.wrap_struct_name = "Rugged::ShutdownHook",
+	.function = {
+		.dmark = NULL,
+		.dfree = cleanup_cb,
+		.dsize = NULL,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 void rugged_exception_raise(void)
 {
 	VALUE err_klass, err_obj;
@@ -678,6 +688,7 @@ void Init_rugged(void)
 
 	/* Hook a global object to cleanup the library
 	 * on shutdown */
-	rb_mShutdownHook = Data_Wrap_Struct(rb_cObject, NULL, &cleanup_cb, NULL);
+	/* Non-NULL data so the GC actually invokes cleanup_cb on shutdown. */
+	rb_mShutdownHook = TypedData_Wrap_Struct(rb_cObject, &rugged_shutdown_hook_type, (void *)1);
 	rb_global_variable(&rb_mShutdownHook);
 }

data/ext/rugged/rugged_blame.c

@@ -10,6 +10,8 @@
 extern VALUE rb_mRugged;
 VALUE rb_cRuggedBlame;
 
+extern const rb_data_type_t rugged_repository_type;
+
 static VALUE rb_git_blame_hunk_fromC(const git_blame_hunk *hunk)
 {
 	VALUE rb_hunk;
@@ -82,6 +84,20 @@ static void rugged_parse_blame_options(git_blame_options *opts, git_repository *
 	}
 }
 
+static void rb_git_blame__free(void *data)
+{
+	git_blame *blame = (git_blame *) data;
+	git_blame_free(blame);
+}
+
+const rb_data_type_t rugged_blame_type = {
+	.wrap_struct_name = "Rugged::Blame",
+	.function = {
+		.dfree = rb_git_blame__free,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 /*
  *  call-seq:
  *    Blame.new(repo, path, options = {}) -> blame
@@ -135,7 +151,7 @@ static VALUE rb_git_blame_new(int argc, VALUE *argv, VALUE klass)
 	rb_scan_args(argc, argv, "20:", &rb_repo, &rb_path, &rb_options);
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	Check_Type(rb_path, T_STRING);
 
@@ -145,7 +161,7 @@ static VALUE rb_git_blame_new(int argc, VALUE *argv, VALUE klass)
 		&blame, repo, StringValueCStr(rb_path), &opts
 	));
 
-	return Data_Wrap_Struct(klass, NULL, &git_blame_free, blame);
+	return TypedData_Wrap_Struct(klass, &rugged_blame_type, blame);
 }
 
 /*
@@ -160,7 +176,7 @@ static VALUE rb_git_blame_for_line(VALUE self, VALUE rb_line_no)
 	git_blame *blame;
 	int line_no;
 
-	Data_Get_Struct(self, git_blame, blame);
+	TypedData_Get_Struct(self, git_blame, &rugged_blame_type, blame);
 	Check_Type(rb_line_no, T_FIXNUM);
 
 	line_no = NUM2INT(rb_line_no);
@@ -184,7 +200,7 @@ static VALUE rb_git_blame_for_line(VALUE self, VALUE rb_line_no)
 static VALUE rb_git_blame_count(VALUE self)
 {
 	git_blame *blame;
-	Data_Get_Struct(self, git_blame, blame);
+	TypedData_Get_Struct(self, git_blame, &rugged_blame_type, blame);
 	return UINT2NUM(git_blame_get_hunk_count(blame));
 }
 
@@ -210,7 +226,7 @@ static VALUE rb_git_blame_get_by_index(VALUE self, VALUE rb_index)
 	int index;
 	uint32_t blame_count;
 
-	Data_Get_Struct(self, git_blame, blame);
+	TypedData_Get_Struct(self, git_blame, &rugged_blame_type, blame);
 	Check_Type(rb_index, T_FIXNUM);
 
 	index = NUM2INT(rb_index);
@@ -249,7 +265,7 @@ static VALUE rb_git_blame_each(VALUE self)
 
 	RETURN_SIZED_ENUMERATOR(self, 0, 0, rugged_blame_enum_size);
 
-	Data_Get_Struct(self, git_blame, blame);
+	TypedData_Get_Struct(self, git_blame, &rugged_blame_type, blame);
 
 	blame_count = git_blame_get_hunk_count(blame);
 	for (i = 0; i < blame_count; ++i) {

data/ext/rugged/rugged_blob.c

@@ -18,6 +18,7 @@ VALUE rb_cRuggedBlob;
 VALUE rb_cRuggedBlobSig;
 
 extern const rb_data_type_t rugged_object_type;
+extern const rb_data_type_t rugged_repository_type;
 
 /*
  *  call-seq:
@@ -143,7 +144,7 @@ static VALUE rb_git_blob_from_buffer(VALUE self, VALUE rb_repo, VALUE rb_buffer)
 	Check_Type(rb_buffer, T_STRING);
 	rugged_check_repo(rb_repo);
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	error = git_blob_create_frombuffer(&oid, repo, RSTRING_PTR(rb_buffer), RSTRING_LEN(rb_buffer));
 	rugged_exception_check(error);
@@ -170,7 +171,7 @@ static VALUE rb_git_blob_from_workdir(VALUE self, VALUE rb_repo, VALUE rb_path)
 	FilePathValue(rb_path);
 	rugged_check_repo(rb_repo);
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	error = git_blob_create_fromworkdir(&oid, repo, StringValueCStr(rb_path));
 	rugged_exception_check(error);
@@ -198,7 +199,7 @@ static VALUE rb_git_blob_from_disk(VALUE self, VALUE rb_repo, VALUE rb_path)
 	FilePathValue(rb_path);
 	rugged_check_repo(rb_repo);
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	error = git_blob_create_fromdisk(&oid, repo, StringValueCStr(rb_path));
 	rugged_exception_check(error);
@@ -253,7 +254,7 @@ static VALUE rb_git_blob_from_io(int argc, VALUE *argv, VALUE klass)
 	rb_scan_args(argc, argv, "21", &rb_repo, &rb_io, &rb_hint_path);
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	if (!NIL_P(rb_hint_path)) {
 		FilePathValue(rb_hint_path);
@@ -507,7 +508,7 @@ static VALUE rb_git_blob_to_buffer(int argc, VALUE *argv, VALUE self)
 	rb_scan_args(argc, argv, "21", &rb_repo, &rb_sha1, &rb_max_bytes);
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	blob = (git_blob *)rugged_object_get(repo, rb_sha1, GIT_OBJ_BLOB);
 
@@ -607,7 +608,7 @@ static VALUE rb_git_blob_merge_files(int argc, VALUE *argv, VALUE klass)
 
 	if (!NIL_P(rb_repo)) {
 		rugged_check_repo(rb_repo);
-		Data_Get_Struct(rb_repo, git_repository, repo);
+		TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 	}
 
 	if (!NIL_P(rb_options))
@@ -638,6 +639,20 @@ done:
 	return rb_result;
 }
 
+static void rb_git_hashsig__free(void *data)
+{
+	git_hashsig *sig = (git_hashsig *) data;
+	git_hashsig_free(sig);
+}
+
+const rb_data_type_t rugged_hashsig_type = {
+	.wrap_struct_name = "Rugged::Blob::HashSignature",
+	.function = {
+		.dfree = rb_git_hashsig__free,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 static VALUE rb_git_blob_sig_new(int argc, VALUE *argv, VALUE klass)
 {
 	int error, opts = 0;
@@ -664,7 +679,7 @@ static VALUE rb_git_blob_sig_new(int argc, VALUE *argv, VALUE klass)
 
 	rugged_exception_check(error);
 
-	return Data_Wrap_Struct(klass, NULL, &git_hashsig_free, sig);
+	return TypedData_Wrap_Struct(klass, &rugged_hashsig_type, sig);
 }
 
 static VALUE rb_git_blob_sig_compare(VALUE self, VALUE rb_sig_a, VALUE rb_sig_b)
@@ -678,8 +693,8 @@ static VALUE rb_git_blob_sig_compare(VALUE self, VALUE rb_sig_a, VALUE rb_sig_b)
 		rb_raise(rb_eTypeError, "Expected Rugged::Blob::HashSignature");
 	}
 
-	Data_Get_Struct(rb_sig_a, git_hashsig, sig_a);
-	Data_Get_Struct(rb_sig_b, git_hashsig, sig_b);
+	TypedData_Get_Struct(rb_sig_a, git_hashsig, &rugged_hashsig_type, sig_a);
+	TypedData_Get_Struct(rb_sig_b, git_hashsig, &rugged_hashsig_type, sig_b);
 
 	result = git_hashsig_compare(sig_a, sig_b);
 

data/ext/rugged/rugged_branch.c

@@ -13,6 +13,9 @@ extern VALUE rb_cRuggedObject;
 extern VALUE rb_cRuggedReference;
 VALUE rb_cRuggedBranch;
 
+extern const rb_data_type_t rugged_reference_type;
+extern const rb_data_type_t rugged_repository_type;
+
 static inline VALUE rugged_branch_new(VALUE owner, git_reference *ref)
 {
 	return rugged_ref_new(rb_cRuggedBranch, owner, ref);
@@ -27,7 +30,7 @@ static inline VALUE rugged_branch_new(VALUE owner, git_reference *ref)
 static VALUE rb_git_branch_head_p(VALUE self)
 {
 	git_reference *branch;
-	Data_Get_Struct(self, git_reference, branch);
+	TypedData_Get_Struct(self, git_reference, &rugged_reference_type, branch);
 	return git_branch_is_head(branch) ? Qtrue : Qfalse;
 }
 
@@ -44,7 +47,7 @@ static VALUE rb_git_branch_name(VALUE self)
 {
 	git_reference *branch;
 	const char *branch_name;
-	Data_Get_Struct(self, git_reference, branch);
+	TypedData_Get_Struct(self, git_reference, &rugged_reference_type, branch);
 
 	rugged_exception_check(git_branch_name(&branch_name, branch));
 
@@ -58,7 +61,7 @@ static VALUE rb_git_branch__remote_name(VALUE rb_repo, const char *canonical_nam
 	int error;
 	VALUE result = Qnil;
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	if ((error = git_branch_remote_name(&remote_name, repo, canonical_name)) == GIT_OK)
 		result = rb_enc_str_new(remote_name.ptr, remote_name.size, rb_utf8_encoding());
@@ -86,7 +89,7 @@ static VALUE rb_git_branch_remote_name(VALUE self)
 	git_reference *branch, *remote_ref;
 	int error = 0;
 
-	Data_Get_Struct(self, git_reference, branch);
+	TypedData_Get_Struct(self, git_reference, &rugged_reference_type, branch);
 
 	if (git_reference_is_remote(branch)) {
 		remote_ref = branch;
@@ -116,7 +119,7 @@ static VALUE rb_git_branch_upstream(VALUE self)
 	git_reference *branch, *upstream_branch;
 	int error;
 
-	Data_Get_Struct(self, git_reference, branch);
+	TypedData_Get_Struct(self, git_reference, &rugged_reference_type, branch);
 
 	if (git_reference_is_remote(branch))
 		return Qnil;
@@ -145,12 +148,12 @@ static VALUE rb_git_branch_set_upstream(VALUE self, VALUE rb_branch)
 	git_reference *branch, *target_branch;
 	const char *target_branch_name;
 
-	Data_Get_Struct(self, git_reference, branch);
+	TypedData_Get_Struct(self, git_reference, &rugged_reference_type, branch);
 	if (!NIL_P(rb_branch)) {
 		if (!rb_obj_is_kind_of(rb_branch, rb_cRuggedReference))
 			rb_raise(rb_eTypeError, "Expecting a Rugged::Reference instance");
 
-		Data_Get_Struct(rb_branch, git_reference, target_branch);
+		TypedData_Get_Struct(rb_branch, git_reference, &rugged_reference_type, target_branch);
 
 		rugged_exception_check(
 			git_branch_name(&target_branch_name, target_branch)

data/ext/rugged/rugged_branch_collection.c

@@ -13,6 +13,8 @@ extern VALUE rb_cRuggedBranch;
 
 VALUE rb_cRuggedBranchCollection;
 
+extern const rb_data_type_t rugged_repository_type;
+
 static inline VALUE rugged_branch_new(VALUE owner, git_reference *ref)
 {
 	return rugged_ref_new(rb_cRuggedBranch, owner, ref);
@@ -119,7 +121,7 @@ static VALUE rb_git_branch_collection_create(int argc, VALUE *argv, VALUE self)
 	rb_scan_args(argc, argv, "20:", &rb_name, &rb_target, &rb_options);
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	Check_Type(rb_name, T_STRING);
 	Check_Type(rb_target, T_STRING);
@@ -164,7 +166,7 @@ static VALUE rb_git_branch_collection_aref(VALUE self, VALUE rb_name) {
 	int error;
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	Check_Type(rb_name, T_STRING);
 
@@ -193,7 +195,7 @@ static VALUE each_branch(int argc, VALUE *argv, VALUE self, int branch_names_onl
 	if (!NIL_P(rb_filter))
 		filter = parse_branch_type(rb_filter);
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	error = git_branch_iterator_new(&iter, repo, filter);
 	rugged_exception_check(error);
@@ -273,7 +275,7 @@ static VALUE rb_git_branch_collection_delete(VALUE self, VALUE rb_name_or_branch
 	int error;
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	error = rugged_branch_lookup(&branch, repo, rb_name_or_branch);
 	rugged_exception_check(error);
@@ -320,7 +322,7 @@ static VALUE rb_git_branch_collection_move(int argc, VALUE *argv, VALUE self)
 	Check_Type(rb_new_branch_name, T_STRING);
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	error = rugged_branch_lookup(&old_branch, repo, rb_name_or_branch);
 	rugged_exception_check(error);
@@ -353,7 +355,7 @@ static VALUE rb_git_branch_collection_exist_p(VALUE self, VALUE rb_name)
 	int error;
 
 	Check_Type(rb_name, T_STRING);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	error = rugged_branch_lookup(&branch, repo, rb_name);
 	git_reference_free(branch);

data/ext/rugged/rugged_commit.c

@@ -16,6 +16,7 @@ extern VALUE rb_cRuggedSignature;
 VALUE rb_cRuggedCommit;
 
 extern const rb_data_type_t rugged_object_type;
+extern const rb_data_type_t rugged_repository_type;
 
 /*
  *  call-seq:
@@ -357,7 +358,7 @@ static VALUE rb_git_commit_amend(VALUE self, VALUE rb_data)
 	TypedData_Get_Struct(self, git_commit, &rugged_object_type, commit_to_amend);
 
 	owner = rugged_owner(self);
-	Data_Get_Struct(owner, git_repository, repo);
+	TypedData_Get_Struct(owner, git_repository, &rugged_repository_type, repo);
 
 	rb_ref = rb_hash_aref(rb_data, CSTR2SYM("update_ref"));
 	if (!NIL_P(rb_ref)) {
@@ -549,7 +550,7 @@ static VALUE rb_git_commit_create(VALUE self, VALUE rb_repo, VALUE rb_data)
 	Check_Type(rb_data, T_HASH);
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	if ((error = parse_commit_options(&commit_data, repo, rb_data)) < 0)
 		goto cleanup;
@@ -614,7 +615,7 @@ static VALUE rb_git_commit_to_mbox(int argc, VALUE *argv, VALUE self)
 	rb_scan_args(argc, argv, ":", &rb_options);
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	TypedData_Get_Struct(self, git_commit, &rugged_object_type, commit);
 
@@ -735,7 +736,7 @@ static VALUE rb_git_commit_extract_signature(int argc, VALUE *argv, VALUE self)
 	rb_scan_args(argc, argv, "21", &rb_repo, &rb_commit, &rb_field);
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	error = git_oid_fromstr(&commit_id, StringValueCStr(rb_commit));
 	rugged_exception_check(error);
@@ -799,7 +800,7 @@ static VALUE rb_git_commit_create_to_s(VALUE self, VALUE rb_repo, VALUE rb_data)
 	Check_Type(rb_data, T_HASH);
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	if ((error = parse_commit_options(&commit_data, repo, rb_data)) < 0)
 		goto cleanup;
@@ -850,7 +851,7 @@ static VALUE rb_git_commit_create_with_signature(int argc, VALUE *argv, VALUE se
 	rb_scan_args(argc, argv, "31", &rb_repo, &rb_content, &rb_signature, &rb_field);
 
 	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	TypedData_Get_Struct(rb_repo, git_repository, &rugged_repository_type, repo);
 
 	Check_Type(rb_content, T_STRING);
 	Check_Type(rb_signature, T_STRING);

data/ext/rugged/rugged_config.c

@@ -10,14 +10,23 @@
 extern VALUE rb_mRugged;
 VALUE rb_cRuggedConfig;
 
-void rb_git_config__free(git_config *config)
+void rb_git_config__free(void *data)
 {
+	git_config *config = (git_config *) data;
 	git_config_free(config);
 }
 
+const rb_data_type_t rugged_config_type = {
+	.wrap_struct_name = "Rugged::config",
+	.function = {
+		.dfree = rb_git_config__free,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE rugged_config_new(VALUE klass, VALUE owner, git_config *cfg)
 {
-	VALUE rb_config = Data_Wrap_Struct(klass, NULL, &rb_git_config__free, cfg);
+	VALUE rb_config = TypedData_Wrap_Struct(klass, &rugged_config_type, cfg);
 	rugged_set_owner(rb_config, owner);
 	return rb_config;
 }
@@ -80,7 +89,7 @@ static VALUE rb_git_config_get(VALUE self, VALUE rb_key)
 	int error;
 	VALUE rb_result;
 
-	Data_Get_Struct(self, git_config, config);
+	TypedData_Get_Struct(self, git_config, &rugged_config_type, config);
 	Check_Type(rb_key, T_STRING);
 
 	error = git_config_get_string_buf(&buf, config, StringValueCStr(rb_key));
@@ -115,7 +124,7 @@ static VALUE rb_git_config_store(VALUE self, VALUE rb_key, VALUE rb_val)
 	const char *key;
 	int error;
 
-	Data_Get_Struct(self, git_config, config);
+	TypedData_Get_Struct(self, git_config, &rugged_config_type, config);
 	Check_Type(rb_key, T_STRING);
 
 	key = StringValueCStr(rb_key);
@@ -158,7 +167,7 @@ static VALUE rb_git_config_delete(VALUE self, VALUE rb_key)
 	git_config *config;
 	int error;
 
-	Data_Get_Struct(self, git_config, config);
+	TypedData_Get_Struct(self, git_config, &rugged_config_type, config);
 	Check_Type(rb_key, T_STRING);
 
 	error = git_config_delete_entry(config, StringValueCStr(rb_key));
@@ -220,7 +229,7 @@ static VALUE rb_git_config_each_key(VALUE self)
 	int error, exception;
 
 	RETURN_ENUMERATOR(self, 0, 0);
-	Data_Get_Struct(self, git_config, config);
+	TypedData_Get_Struct(self, git_config, &rugged_config_type, config);
 
 	error = git_config_foreach(config, &cb_config__each_key, &exception);
 	if (error == GIT_EUSER)
@@ -250,7 +259,7 @@ static VALUE rb_git_config_each_pair(VALUE self)
 	int error, exception;
 
 	RETURN_ENUMERATOR(self, 0, 0);
-	Data_Get_Struct(self, git_config, config);
+	TypedData_Get_Struct(self, git_config, &rugged_config_type, config);
 
 	error = git_config_foreach(config, &cb_config__each_pair, &exception);
 	if (error == GIT_EUSER)
@@ -276,7 +285,7 @@ static VALUE rb_git_config_to_hash(VALUE self)
 	int error;
 	VALUE hash;
 
-	Data_Get_Struct(self, git_config, config);
+	TypedData_Get_Struct(self, git_config, &rugged_config_type, config);
 	hash = rb_hash_new();
 
 	error = git_config_foreach(config, &cb_config__to_hash, (void *)hash);
@@ -317,7 +326,7 @@ static VALUE rb_git_config_snapshot(VALUE self)
 {
 	git_config *config, *snapshot;
 
-	Data_Get_Struct(self, git_config, config);
+	TypedData_Get_Struct(self, git_config, &rugged_config_type, config);
 
 	rugged_exception_check(
 		git_config_snapshot(&snapshot, config)
@@ -348,7 +357,7 @@ static VALUE rb_git_config_transaction(VALUE self)
 	VALUE rb_result;
 	int error = 0, exception = 0;
 
-	Data_Get_Struct(self, git_config, config);
+	TypedData_Get_Struct(self, git_config, &rugged_config_type, config);
 
 	git_config_lock(&tx, config);
 
@@ -392,7 +401,7 @@ static VALUE rb_git_config_get_all(VALUE self, VALUE key)
 	VALUE list;
 	int error;
 
-	Data_Get_Struct(self, git_config, config);
+	TypedData_Get_Struct(self, git_config, &rugged_config_type, config);
 
 	list = rb_ary_new();
 	error = git_config_get_multivar_foreach(

data/ext/rugged/rugged_diff.c

@@ -10,9 +10,23 @@
 extern VALUE rb_mRugged;
 VALUE rb_cRuggedDiff;
 
+static void rb_git_diff__free(void *data)
+{
+	git_diff *diff = (git_diff *) data;
+	git_diff_free(diff);
+}
+
+const rb_data_type_t rugged_diff_type = {
+	.wrap_struct_name = "Rugged::Diff",
+	.function = {
+		.dfree = rb_git_diff__free,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE rugged_diff_new(VALUE klass, VALUE owner, git_diff *diff)
 {
-	VALUE rb_diff = Data_Wrap_Struct(klass, NULL, git_diff_free, diff);
+	VALUE rb_diff = TypedData_Wrap_Struct(klass, &rugged_diff_type, diff);
 	rugged_set_owner(rb_diff, owner);
 	return rb_diff;
 }
@@ -212,7 +226,7 @@ static VALUE rb_git_diff_patch(int argc, VALUE *argv, VALUE self)
 
 	rb_scan_args(argc, argv, "00:", &rb_opts);
 
-	Data_Get_Struct(self, git_diff, diff);
+	TypedData_Get_Struct(self, git_diff, &rugged_diff_type, diff);
 
 	if (!NIL_P(rb_opts)) {
 		if (rb_hash_aref(rb_opts, CSTR2SYM("compact")) == Qtrue)
@@ -256,7 +270,7 @@ static VALUE rb_git_diff_write_patch(int argc, VALUE *argv, VALUE self)
 	if (!rb_respond_to(rb_io, rb_intern("write")))
 		rb_raise(rb_eArgError, "Expected io to respond to \"write\"");
 
-	Data_Get_Struct(self, git_diff, diff);
+	TypedData_Get_Struct(self, git_diff, &rugged_diff_type, diff);
 
 	if (!NIL_P(rb_opts)) {
 		if (rb_hash_aref(rb_opts, CSTR2SYM("compact")) == Qtrue)
@@ -285,8 +299,8 @@ static VALUE rb_git_diff_merge(VALUE self, VALUE rb_other)
 	if (!rb_obj_is_kind_of(rb_other, rb_cRuggedDiff))
 		rb_raise(rb_eTypeError, "A Rugged::Diff instance is required");
 
-	Data_Get_Struct(self, git_diff, diff);
-	Data_Get_Struct(rb_other, git_diff, other);
+	TypedData_Get_Struct(self, git_diff, &rugged_diff_type, diff);
+	TypedData_Get_Struct(rb_other, git_diff, &rugged_diff_type, other);
 
 	error = git_diff_merge(diff, other);
 	rugged_exception_check(error);
@@ -358,7 +372,7 @@ static VALUE rb_git_diff_find_similar(int argc, VALUE *argv, VALUE self)
 	VALUE rb_options;
 	int error;
 
-	Data_Get_Struct(self, git_diff, diff);
+	TypedData_Get_Struct(self, git_diff, &rugged_diff_type, diff);
 
 	rb_scan_args(argc, argv, "00:", &rb_options);
 
@@ -448,7 +462,7 @@ static VALUE rb_git_diff_each_patch(VALUE self)
 	size_t d, delta_count;
 
 	RETURN_ENUMERATOR(self, 0, 0);
-	Data_Get_Struct(self, git_diff, diff);
+	TypedData_Get_Struct(self, git_diff, &rugged_diff_type, diff);
 
 	delta_count = git_diff_num_deltas(diff);
 	for (d = 0; d < delta_count; ++d) {
@@ -481,7 +495,7 @@ static VALUE rb_git_diff_each_delta(VALUE self)
 	size_t d, delta_count;
 
 	RETURN_ENUMERATOR(self, 0, 0);
-	Data_Get_Struct(self, git_diff, diff);
+	TypedData_Get_Struct(self, git_diff, &rugged_diff_type, diff);
 
 	delta_count = git_diff_num_deltas(diff);
 	for (d = 0; d < delta_count; ++d) {
@@ -516,7 +530,7 @@ static VALUE rb_git_diff_each_line(int argc, VALUE *argv, VALUE self)
 	int exception = 0, error;
 
 	RETURN_ENUMERATOR(self, argc, argv);
-	Data_Get_Struct(self, git_diff, diff);
+	TypedData_Get_Struct(self, git_diff, &rugged_diff_type, diff);
 
 	if (rb_scan_args(argc, argv, "01", &rb_format) == 1) {
 		Check_Type(rb_format, T_SYMBOL);
@@ -557,7 +571,7 @@ static VALUE rb_git_diff_size(VALUE self)
 {
 	git_diff *diff;
 
-	Data_Get_Struct(self, git_diff, diff);
+	TypedData_Get_Struct(self, git_diff, &rugged_diff_type, diff);
 
 	return INT2FIX(git_diff_num_deltas(diff));
 }
@@ -616,7 +630,7 @@ static VALUE rb_git_diff_stat(VALUE self)
 	git_diff *diff;
 	struct diff_stats stats = { 0, 0, 0 };
 
-	Data_Get_Struct(self, git_diff, diff);
+	TypedData_Get_Struct(self, git_diff, &rugged_diff_type, diff);
 
 	git_diff_foreach(
 		diff, diff_file_stats_cb, NULL, NULL, diff_line_stats_cb, &stats);
@@ -633,7 +647,7 @@ static VALUE rb_git_diff_stat(VALUE self)
 static VALUE rb_git_diff_sorted_icase_p(VALUE self)
 {
 	git_diff *diff;
-	Data_Get_Struct(self, git_diff, diff);
+	TypedData_Get_Struct(self, git_diff, &rugged_diff_type, diff);
 	return git_diff_is_sorted_icase(diff) ? Qtrue : Qfalse;
 }
 

data/ext/rugged/rugged_diff_hunk.c

@@ -10,6 +10,7 @@
 extern VALUE rb_cRuggedDiff;
 VALUE rb_cRuggedDiffHunk;
 
+extern const rb_data_type_t rugged_patch_type;
 
 VALUE rugged_diff_hunk_new(VALUE owner, size_t hunk_idx, const git_diff_hunk *hunk, size_t lines_in_hunk)
 {
@@ -44,7 +45,7 @@ static VALUE rb_git_diff_hunk_each_line(VALUE self)
 
 	RETURN_ENUMERATOR(self, 0, 0);
 
-	Data_Get_Struct(rugged_owner(self), git_patch, patch);
+	TypedData_Get_Struct(rugged_owner(self), git_patch, &rugged_patch_type, patch);
 
 	lines_count = FIX2INT(rb_iv_get(self, "@line_count"));
 	hunk_idx = FIX2INT(rb_iv_get(self, "@hunk_index"));