rugged 0.27.10.1 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70a778d31c690a9546c49bf2de625d251c624dc75e9a01171ed7922e67907699
-  data.tar.gz: 781194f36ca5ac19cfc475b05d61aca788b76421e698e4647e172a05744bef3a
+  metadata.gz: 28cda5c3e68cfdf6edcf8efb20157b83af045c61009b9d84ef45d04307222f68
+  data.tar.gz: 6136a85649898880308af6d3ae92d3c3ac1802fe3b4595b826129ad4bdb9375d
 SHA512:
-  metadata.gz: 246a7592db8403acb93af774908a97a155d283b760354818ead1caf4da87129d24a0462c919b5ead6e55a9b0af979e0b212bb4775d321ac136dfe8d1f9e38bc6
-  data.tar.gz: 72ccb7c78702e23f96df9e1f1508ff24ac4a3c518eef498a94b3598ce2f657cca80794451cee7984a2b111ad7a6cb815007f8f4da2d7e4435df48cc4db5afa31
+  metadata.gz: 4893ace2448d29b3945a0d45bc0770d2543dc5c40f8fafd9530fe41d9f52715f008f7c88510115bb9c1413fd5a434ef60d636f7544f96a0057fc65051a4d8efa
+  data.tar.gz: d3df3dad58a2405fa3da033bb5d3debb25d80f37563c342247099a390b663b807ca75b993cbde772e27d108e56b6590bfe921b3e1fcd9e64c897e97345c614af

data/ext/rugged/extconf.rb

@@ -4,6 +4,7 @@
 # For full terms see the included LICENSE file.
 
 require 'mkmf'
+require 'timeout'
 
 RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
 
@@ -23,6 +24,26 @@ def sys(cmd)
   ret
 end
 
+# Thrown when we detect CMake is taking too long and we killed it
+class CMakeTimeout < StandardError
+end
+
+def self.run_cmake(timeout, args)
+  # Set to process group so we can kill it and its children
+  pid = Process.spawn("cmake #{args}", pgroup: true)
+
+  Timeout.timeout(timeout) do
+    Process.waitpid(pid)
+  end
+
+rescue Timeout::Error
+  # Kill it, #detach is essentially a background wait, since we don't actually
+  # care about waiting for it now
+  Process.kill(-9, pid)
+  Process.detach(pid)
+  raise CMakeTimeout.new("cmake has exceeded its timeout of #{timeout}s")
+end
+
 MAKE = if Gem.win_platform?
   # On Windows, Ruby-DevKit only has 'make'.
   find_executable('make')
@@ -80,7 +101,7 @@ else
     Dir.chdir("build") do
       # On Windows, Ruby-DevKit is MSYS-based, so ensure to use MSYS Makefiles.
       generator = "-G \"MSYS Makefiles\"" if Gem.win_platform?
-      sys("cmake .. -DBUILD_CLAR=OFF -DTHREADSAFE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_C_FLAGS=-fPIC -DCMAKE_BUILD_TYPE=RelWithDebInfo #{cmake_flags.join(' ')} #{generator}")
+      run_cmake(5 * 60, ".. -DBUILD_CLAR=OFF -DTHREADSAFE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_C_FLAGS=-fPIC -DCMAKE_BUILD_TYPE=RelWithDebInfo #{cmake_flags.join(' ')} #{generator}")
       sys(MAKE)
 
       # "normal" libraries (and libgit2 builds) get all these when they build but we're doing it
@@ -88,7 +109,7 @@ else
       # in $LIBS or the final linking stage won't pick them up
       if Gem.win_platform?
         $LDFLAGS << " " + "-L#{Dir.pwd}/deps/winhttp"
-        $LIBS << " -lwinhttp -lcrypt32 -lrpcrt4 -lole32 -lz"
+        $LIBS << " -lwinhttp -lcrypt32 -lrpcrt4 -lole32 -lz -lssh2"
       else
         pcfile = File.join(LIBGIT2_DIR, "build", "libgit2.pc")
         $LDFLAGS << " " + `pkg-config --libs --static #{pcfile}`.strip

data/ext/rugged/rugged.c

@@ -210,7 +210,7 @@ static VALUE rb_git_prettify_message(int argc, VALUE *argv, VALUE self)
 	if (!error)
 		result = rb_enc_str_new(message.ptr, message.size, rb_utf8_encoding());
 
-	git_buf_free(&message);
+	git_buf_dispose(&message);
 	rugged_exception_check(error);
 
 	return result;
@@ -515,6 +515,48 @@ VALUE rb_merge_file_result_fromC(const git_merge_file_result *result)
 	return rb_result;
 }
 
+static VALUE rb_git_path_is_dotgit_modules(VALUE self, VALUE rb_path)
+{
+	const char *path;
+	int is_dotgit;
+
+	Check_Type(rb_path, T_STRING);
+
+	path = StringValueCStr(rb_path);
+
+	is_dotgit = git_path_is_gitfile(path, strlen(path), GIT_PATH_GITFILE_GITMODULES, GIT_PATH_FS_GENERIC);
+
+	return is_dotgit ? Qtrue : Qfalse;
+}
+
+static VALUE rb_git_path_is_dotgit_ignore(VALUE self, VALUE rb_path)
+{
+	const char *path;
+	int is_dotgit;
+
+	Check_Type(rb_path, T_STRING);
+
+	path = StringValueCStr(rb_path);
+
+	is_dotgit = git_path_is_gitfile(path, strlen(path), GIT_PATH_GITFILE_GITIGNORE, GIT_PATH_FS_GENERIC);
+
+	return is_dotgit ? Qtrue : Qfalse;
+}
+
+static VALUE rb_git_path_is_dotgit_attributes(VALUE self, VALUE rb_path)
+{
+	const char *path;
+	int is_dotgit;
+
+	Check_Type(rb_path, T_STRING);
+
+	path = StringValueCStr(rb_path);
+
+	is_dotgit = git_path_is_gitfile(path, strlen(path), GIT_PATH_GITFILE_GITATTRIBUTES, GIT_PATH_FS_GENERIC);
+
+	return is_dotgit ? Qtrue : Qfalse;
+}
+
 void Init_rugged(void)
 {
 	rb_mRugged = rb_define_module("Rugged");
@@ -544,6 +586,9 @@ void Init_rugged(void)
 	rb_define_module_function(rb_mRugged, "prettify_message", rb_git_prettify_message, -1);
 	rb_define_module_function(rb_mRugged, "__cache_usage__", rb_git_cache_usage, 0);
 	rb_define_module_function(rb_mRugged, "signature_from_buffer", rb_git_signature_from_buffer, -1);
+	rb_define_module_function(rb_mRugged, "dotgit_modules?", rb_git_path_is_dotgit_modules, 1);
+	rb_define_module_function(rb_mRugged, "dotgit_ignore?", rb_git_path_is_dotgit_ignore, 1);
+	rb_define_module_function(rb_mRugged, "dotgit_attributes?", rb_git_path_is_dotgit_attributes, 1);
 
 	Init_rugged_reference();
 	Init_rugged_reference_collection();
@@ -604,7 +649,8 @@ void Init_rugged(void)
 	 */
 	rb_define_const(rb_mRugged, "SORT_REVERSE", INT2FIX(GIT_SORT_REVERSE));
 
-	/* Initialize libgit2 */
+	/* Set the allocator and initialize libgit2 */
+	rugged_set_allocator();
 	git_libgit2_init();
 
 	/* Hook a global object to cleanup the library

data/ext/rugged/rugged.h

@@ -20,9 +20,12 @@
 #include <ruby/encoding.h>
 #endif
 
+#include <ruby/util.h>
+
 #include <assert.h>
 #include <git2.h>
 #include <git2/odb_backend.h>
+#include <git2/sys/path.h>
 
 #define rb_str_new_utf8(str) rb_enc_str_new(str, strlen(str), rb_utf8_encoding())
 #define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
@@ -173,4 +176,6 @@ typedef struct _rugged_backend {
   int (* refdb_backend)(git_refdb_backend **backend_out, struct _rugged_backend *backend, const char* path);
 } rugged_backend;
 
+extern void rugged_set_allocator(void);
+
 #endif

data/ext/rugged/rugged_allocator.c

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) the Rugged contributors.  All rights reserved.
+ *
+ * This file is part of Rugged, distributed under the MIT license.
+ * For full terms see the included LICENSE file.
+ */
+
+#include "rugged.h"
+#include <git2/sys/alloc.h>
+
+static void *rugged_gmalloc(size_t n, const char *file, int line)
+{
+	return xmalloc(n);
+}
+
+static void *rugged_gcalloc(size_t nelem, size_t elsize, const char *file, int line)
+{
+	return xcalloc(nelem, elsize);
+}
+
+static char *rugged_gstrdup(const char *str, const char *file, int line)
+{
+	return ruby_strdup(str);
+}
+
+static char *rugged_gstrndup(const char *str, size_t n, const char *file, int line)
+{
+	size_t len;
+	char *newstr;
+
+	len = strnlen(str, n);
+	if (len < n)
+		n = len;
+
+	newstr = xmalloc(n+1);
+	memcpy(newstr, str, n);
+	newstr[n] = '\0';
+
+	return newstr;
+}
+
+static char *rugged_gsubstrdup(const char *str, size_t n, const char *file, int line)
+{
+	char *newstr;
+
+	newstr = xmalloc(n+1);
+	memcpy(newstr, str, n);
+	newstr[n] = '\0';
+
+	return newstr;
+}
+
+static void *rugged_grealloc(void *ptr, size_t size, const char *file, int line)
+{
+	return xrealloc(ptr, size);
+}
+
+static void *rugged_greallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line)
+{
+	return xrealloc2(ptr, nelem, elsize);
+}
+
+static void *rugged_gmallocarray(size_t nelem, size_t elsize, const char *file, int line)
+{
+	return xmalloc2(nelem, elsize);
+}
+
+static void rugged_gfree(void *ptr)
+{
+	xfree(ptr);
+}
+
+void rugged_set_allocator(void)
+{
+	git_allocator allocator;
+
+	allocator.gmalloc = rugged_gmalloc;
+	allocator.gcalloc = rugged_gcalloc;
+	allocator.gstrdup = rugged_gstrdup;
+	allocator.gstrndup = rugged_gstrndup;
+	allocator.gstrndup = rugged_gstrndup;
+	allocator.gsubstrdup = rugged_gsubstrdup;
+	allocator.grealloc = rugged_grealloc;
+	allocator.greallocarray = rugged_greallocarray;
+	allocator.gmallocarray = rugged_gmallocarray;
+	allocator.gfree = rugged_gfree;
+
+	git_libgit2_opts(GIT_OPT_SET_ALLOCATOR, &allocator);
+}

data/ext/rugged/rugged_blob.c

@@ -165,7 +165,7 @@ static VALUE rb_git_blob_from_workdir(VALUE self, VALUE rb_repo, VALUE rb_path)
 	git_oid oid;
 	git_repository *repo;
 
-	Check_Type(rb_path, T_STRING);
+	FilePathValue(rb_path);
 	rugged_check_repo(rb_repo);
 
 	Data_Get_Struct(rb_repo, git_repository, repo);
@@ -193,7 +193,7 @@ static VALUE rb_git_blob_from_disk(VALUE self, VALUE rb_repo, VALUE rb_path)
 	git_oid oid;
 	git_repository *repo;
 
-	Check_Type(rb_path, T_STRING);
+	FilePathValue(rb_path);
 	rugged_check_repo(rb_repo);
 
 	Data_Get_Struct(rb_repo, git_repository, repo);
@@ -254,7 +254,7 @@ static VALUE rb_git_blob_from_io(int argc, VALUE *argv, VALUE klass)
 	Data_Get_Struct(rb_repo, git_repository, repo);
 
 	if (!NIL_P(rb_hint_path)) {
-		Check_Type(rb_hint_path, T_STRING);
+		FilePathValue(rb_hint_path);
 		hint_path = StringValueCStr(rb_hint_path);
 	}
 

data/ext/rugged/rugged_branch.c

@@ -63,7 +63,7 @@ static VALUE rb_git_branch__remote_name(VALUE rb_repo, const char *canonical_nam
 	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());
 
-	git_buf_free(&remote_name);
+	git_buf_dispose(&remote_name);
 	rugged_exception_check(error);
 
 	return result;

data/ext/rugged/rugged_commit.c

@@ -649,7 +649,7 @@ static VALUE rb_git_commit_to_mbox(int argc, VALUE *argv, VALUE self)
 	cleanup:
 
 	xfree(opts.pathspec.strings);
-	git_buf_free(&email_patch);
+	git_buf_dispose(&email_patch);
 	rugged_exception_check(error);
 
 	return rb_email_patch;
@@ -678,7 +678,7 @@ static VALUE rb_git_commit_header_field(VALUE self, VALUE rb_field)
 	error = git_commit_header_field(&header_field, commit, StringValueCStr(rb_field));
 
 	if (error < 0) {
-		git_buf_free(&header_field);
+		git_buf_dispose(&header_field);
 		if (error == GIT_ENOTFOUND)
 			return Qnil;
 		rugged_exception_check(error);
@@ -689,7 +689,7 @@ static VALUE rb_git_commit_header_field(VALUE self, VALUE rb_field)
 		encoding = rb_enc_find(encoding_name);
 
 	rb_result = rb_enc_str_new(header_field.ptr, header_field.size, encoding);
-	git_buf_free(&header_field);
+	git_buf_dispose(&header_field);
 	return rb_result;
 }
 
@@ -741,8 +741,8 @@ static VALUE rb_git_commit_extract_signature(int argc, VALUE *argv, VALUE self)
 	field = NIL_P(rb_field) ? NULL : StringValueCStr(rb_field);
 	error = git_commit_extract_signature(&signature, &signed_data, repo, &commit_id, field);
 	if (error < 0) {
-		git_buf_free(&signature);
-		git_buf_free(&signed_data);
+		git_buf_dispose(&signature);
+		git_buf_dispose(&signed_data);
 	}
 
 	if (error == GIT_ENOTFOUND && giterr_last()->klass == GITERR_OBJECT ) {
@@ -754,8 +754,8 @@ static VALUE rb_git_commit_extract_signature(int argc, VALUE *argv, VALUE self)
 				     rb_str_new(signed_data.ptr, signed_data.size));
 	}
 
-	git_buf_free(&signature);
-	git_buf_free(&signed_data);
+	git_buf_dispose(&signature);
+	git_buf_dispose(&signed_data);
 
 	return ret;
 }
@@ -821,7 +821,7 @@ cleanup:
 	rugged_exception_check(error);
 
 	ret = rb_str_new_utf8(buf.ptr);
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 
 	return ret;
 }

data/ext/rugged/rugged_config.c

@@ -89,7 +89,7 @@ static VALUE rb_git_config_get(VALUE self, VALUE rb_key)
 
 	rugged_exception_check(error);
 	rb_result = rb_str_new_utf8(buf.ptr);
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 
 	return rb_result;
 }

data/ext/rugged/rugged_diff.c

@@ -6,6 +6,7 @@
  */
 
 #include "rugged.h"
+#include <ruby/thread.h>
 
 extern VALUE rb_mRugged;
 VALUE rb_cRuggedDiff;
@@ -197,6 +198,20 @@ static int diff_print_cb(
 	return GIT_OK;
 }
 
+struct nogvl_diff_patch_args {
+	git_diff * diff;
+	git_diff_format_t format;
+	VALUE rb_str;
+};
+
+static void rb_git_diff_patch_nogvl(void * _args)
+{
+	struct nogvl_diff_patch_args * args;
+
+	args = (struct nogvl_diff_patch_args *)_args;
+	git_diff_print(args->diff, args->format, diff_print_cb, (void*) args->rb_str);
+}
+
 /*
  *  call-seq:
  *    diff.patch -> patch
@@ -209,6 +224,8 @@ static VALUE rb_git_diff_patch(int argc, VALUE *argv, VALUE self)
 	git_diff *diff;
 	VALUE rb_str = rb_str_new(NULL, 0);
 	VALUE rb_opts;
+	struct nogvl_diff_patch_args args;
+	git_diff_format_t format = GIT_DIFF_FORMAT_PATCH;
 
 	rb_scan_args(argc, argv, "00:", &rb_opts);
 
@@ -216,13 +233,16 @@ static VALUE rb_git_diff_patch(int argc, VALUE *argv, VALUE self)
 
 	if (!NIL_P(rb_opts)) {
 		if (rb_hash_aref(rb_opts, CSTR2SYM("compact")) == Qtrue)
-			git_diff_print(diff, GIT_DIFF_FORMAT_NAME_STATUS, diff_print_cb, (void*)rb_str);
+			format = GIT_DIFF_FORMAT_NAME_STATUS;
 		else
-			git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, diff_print_cb, (void*)rb_str);
-	} else {
-		git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, diff_print_cb, (void*)rb_str);
+			format = GIT_DIFF_FORMAT_PATCH;
 	}
 
+	args.diff = diff;
+	args.format = format;
+	args.rb_str = rb_str;
+	rb_thread_call_without_gvl(rb_git_diff_patch_nogvl, &args, RUBY_UBF_PROCESS, NULL);
+
 	return rb_str;
 }
 

data/ext/rugged/rugged_note.c

@@ -340,7 +340,7 @@ static VALUE rb_git_note_default_ref_GET(VALUE self)
 
 	rb_result = rb_enc_str_new(ref_name.ptr, ref_name.size, rb_utf8_encoding());
 
-	git_buf_free(&ref_name);
+	git_buf_dispose(&ref_name);
 
 	return rb_result;
 }

data/ext/rugged/rugged_repo.c

@@ -182,7 +182,7 @@ static void rugged_repo_new_with_backend(git_repository **repo, VALUE rb_path, V
 
 	int error = 0;
 
-	Check_Type(rb_path, T_STRING);
+	FilePathValue(rb_path);
 	path = StringValueCStr(rb_path);
 
 	if (rb_obj_is_kind_of(rb_backend, rb_cRuggedBackend) == Qfalse) {
@@ -291,7 +291,7 @@ static VALUE rb_git_repo_open_bare(int argc, VALUE *argv, VALUE klass)
 	}
 
 	if (!repo) {
-		Check_Type(rb_path, T_STRING);
+		FilePathValue(rb_path);
 
 		error = git_repository_open_bare(&repo, StringValueCStr(rb_path));
 		rugged_exception_check(error);
@@ -335,7 +335,7 @@ static VALUE rb_git_repo_new(int argc, VALUE *argv, VALUE klass)
 	VALUE rb_path, rb_options;
 
 	rb_scan_args(argc, argv, "10:", &rb_path, &rb_options);
-	Check_Type(rb_path, T_STRING);
+	FilePathValue(rb_path);
 
 	error = git_repository_open(&repo, StringValueCStr(rb_path));
 	rugged_exception_check(error);
@@ -377,7 +377,7 @@ static VALUE rb_git_repo_init_at(int argc, VALUE *argv, VALUE klass)
 	int error;
 
 	rb_scan_args(argc, argv, "11:", &rb_path, &rb_is_bare, &rb_options);
-	Check_Type(rb_path, T_STRING);
+	FilePathValue(rb_path);
 
 	if (!NIL_P(rb_options)) {
 		/* Check for `:backend` */
@@ -474,7 +474,7 @@ static VALUE rb_git_repo_clone_at(int argc, VALUE *argv, VALUE klass)
 
 	rb_scan_args(argc, argv, "21", &url, &local_path, &rb_options_hash);
 	Check_Type(url, T_STRING);
-	Check_Type(local_path, T_STRING);
+	FilePathValue(local_path);
 
 	parse_clone_options(&options, rb_options_hash, &remote_payload);
 
@@ -1180,7 +1180,7 @@ static VALUE rb_git_repo_hashfile(VALUE self, VALUE rb_path, VALUE rb_type)
 	int error;
 	git_oid oid;
 
-	Check_Type(rb_path, T_STRING);
+	FilePathValue(rb_path);
 
 	error = git_odb_hashfile(&oid,
 		StringValueCStr(rb_path),
@@ -1455,7 +1455,7 @@ static VALUE rb_git_repo_discover(int argc, VALUE *argv, VALUE klass)
 		across_fs = rugged_parse_bool(rb_across_fs);
 	}
 
-	Check_Type(rb_path, T_STRING);
+	FilePathValue(rb_path);
 
 	error = git_repository_discover(
 		&repository_path,
@@ -1467,7 +1467,7 @@ static VALUE rb_git_repo_discover(int argc, VALUE *argv, VALUE klass)
 	rugged_exception_check(error);
 
 	error = git_repository_open(&repo, repository_path.ptr);
-	git_buf_free(&repository_path);
+	git_buf_dispose(&repository_path);
 
 	rugged_exception_check(error);
 
@@ -1518,7 +1518,7 @@ static VALUE rb_git_repo_file_status(VALUE self, VALUE rb_path)
 	git_repository *repo;
 
 	Data_Get_Struct(self, git_repository, repo);
-	Check_Type(rb_path, T_STRING);
+	FilePathValue(rb_path);
 	error = git_status_file(&flags, repo, StringValueCStr(rb_path));
 	rugged_exception_check(error);
 
@@ -2365,7 +2365,7 @@ static VALUE rb_git_repo_attributes(int argc, VALUE *argv, VALUE self)
 	rb_scan_args(argc, argv, "12", &rb_path, &rb_names, &rb_options);
 
 	Data_Get_Struct(self, git_repository, repo);
-	Check_Type(rb_path, T_STRING);
+	FilePathValue(rb_path);
 
 	if (!NIL_P(rb_options)) {
 		Check_Type(rb_options, T_FIXNUM);