rugged 0.25.0b8 → 0.25.0b9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9436b2f4df762f300fb1103b01d8f80c4973441a
-  data.tar.gz: fffa3a995093034dac0762800d16fb6d6fa9d38b
+  metadata.gz: 446553349654cfec5239ed7c7bbb2d3cc57034fb
+  data.tar.gz: 0e580f2767fe9eefac9073fc31f9d53eb997669b
 SHA512:
-  metadata.gz: afad4fb30f5ba7c31ba25714422e2941df978bfd3df5c72d2510ce2c5372769bb74ee5ab0e24115d1e52a19dd84fbf3289453d187253a9f1f63fb6cd294d6c95
-  data.tar.gz: 7f5c92919ec876e1ba8a3c042fe9de29b632c4d5be8ed327c9e2226c6424d401b132b25f347c52000c7a1287d0958c7ff59a9768af4c2da3c4fe066a5ec776e4
+  metadata.gz: c6ce0b1c7541b0250884c74acb03932c2d15b978b85e816328e3d12daab134e1500289674aa2652aaad68c81144fc573a6de3f8b04837c81165e7b31179535ae
+  data.tar.gz: 5cc83ce5093f126becab5c0647efe98664f3fe03bdd9c4c6ea0845ef75e541bbdfc63e9edd5caa92ecb76681f11ac73333d247e7506f0ef71a63f508b4f55ac7

data/ext/rugged/extconf.rb

@@ -77,7 +77,7 @@ else
       # in $LIBS or the final linking stage won't pick them up
       if windows?
         $LDFLAGS << " " + "-L#{Dir.pwd}/deps/winhttp"
-        $LIBS << " -lwinhttp -lcrypt32 -lrpcrt4 -lole32"
+        $LIBS << " -lwinhttp -lcrypt32 -lrpcrt4 -lole32 -lz"
       else
         pcfile = File.join(LIBGIT2_DIR, "build", "libgit2.pc")
         $LDFLAGS << " " + `pkg-config --libs --static #{pcfile}`.strip

data/ext/rugged/rugged.c

@@ -428,6 +428,87 @@ void rugged_rb_ary_to_strarray(VALUE rb_array, git_strarray *str_array)
 	}
 }
 
+void rugged_parse_merge_file_options(git_merge_file_options *opts, VALUE rb_options)
+{
+	VALUE rb_value;
+
+	Check_Type(rb_options, T_HASH);
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("ancestor_label"));
+	if (!NIL_P(rb_value)) {
+		Check_Type(rb_value, T_STRING);
+		opts->ancestor_label = StringValueCStr(rb_value);
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("our_label"));
+	if (!NIL_P(rb_value)) {
+		Check_Type(rb_value, T_STRING);
+		opts->our_label = StringValueCStr(rb_value);
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("their_label"));
+	if (!NIL_P(rb_value)) {
+		Check_Type(rb_value, T_STRING);
+		opts->their_label = StringValueCStr(rb_value);
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("favor"));
+	if (!NIL_P(rb_value)) {
+		ID id_favor;
+
+		Check_Type(rb_value, T_SYMBOL);
+		id_favor = SYM2ID(rb_value);
+
+		if (id_favor == rb_intern("normal")) {
+			opts->favor = GIT_MERGE_FILE_FAVOR_NORMAL;
+		} else if (id_favor == rb_intern("ours")) {
+			opts->favor = GIT_MERGE_FILE_FAVOR_OURS;
+		} else if (id_favor == rb_intern("theirs")) {
+			opts->favor = GIT_MERGE_FILE_FAVOR_THEIRS;
+		} else if (id_favor == rb_intern("union")) {
+			opts->favor = GIT_MERGE_FILE_FAVOR_UNION;
+		} else {
+			rb_raise(rb_eTypeError,
+				"Invalid favor mode. Expected `:normal`, `:ours`, `:theirs` or `:union`");
+		}
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("style"));
+	if (!NIL_P(rb_value)) {
+		ID id_style;
+
+		Check_Type(rb_value, T_SYMBOL);
+		id_style = SYM2ID(rb_value);
+
+		if (id_style == rb_intern("standard")) {
+			opts->flags |= GIT_MERGE_FILE_STYLE_MERGE;
+		} else if (id_style == rb_intern("diff3")) {
+			opts->flags |= GIT_MERGE_FILE_STYLE_DIFF3;
+		} else {
+			rb_raise(rb_eTypeError,
+				"Invalid style mode. Expected `:standard`, or `:diff3`");
+		}
+	} else {
+		opts->flags |= GIT_MERGE_FILE_STYLE_MERGE;
+	}
+
+	if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("simplify")))) {
+		opts->flags |= GIT_MERGE_FILE_SIMPLIFY_ALNUM;
+	}
+}
+
+VALUE rb_merge_file_result_fromC(const git_merge_file_result *result)
+{
+	VALUE rb_result = rb_hash_new();
+
+	rb_hash_aset(rb_result, CSTR2SYM("automergeable"), result->automergeable ? Qtrue : Qfalse);
+	rb_hash_aset(rb_result, CSTR2SYM("path"),          result->path ? rb_str_new_utf8(result->path) : Qnil);
+	rb_hash_aset(rb_result, CSTR2SYM("filemode"),      INT2FIX(result->mode));
+	rb_hash_aset(rb_result, CSTR2SYM("data"),          rb_str_new(result->ptr, result->len));
+
+	return rb_result;
+}
+
 void Init_rugged(void)
 {
 	rb_mRugged = rb_define_module("Rugged");

data/ext/rugged/rugged.h

@@ -96,10 +96,12 @@ VALUE rugged_diff_hunk_new(VALUE owner, size_t hunk_idx, const git_diff_hunk *hu
 VALUE rugged_diff_line_new(const git_diff_line *line);
 VALUE rugged_remote_new(VALUE owner, git_remote *remote);
 VALUE rb_git_delta_file_fromC(const git_diff_file *file);
+VALUE rb_merge_file_result_fromC(const git_merge_file_result *results);
 
 void rugged_parse_diff_options(git_diff_options *opts, VALUE rb_options);
 void rugged_parse_merge_options(git_merge_options *opts, VALUE rb_options);
 void rugged_parse_checkout_options(git_checkout_options *opts, VALUE rb_options);
+void rugged_parse_merge_file_options(git_merge_file_options *opts, VALUE rb_options);
 
 void rugged_cred_extract(git_cred **cred, int allowed_types, VALUE rb_credential);
 
@@ -157,6 +159,7 @@ struct rugged_remote_cb_payload
 	VALUE transfer_progress;
 	VALUE update_tips;
 	VALUE credentials;
+	VALUE certificate_check;
 	VALUE result;
 	int exception;
 };

data/ext/rugged/rugged_blob.c

@@ -551,6 +551,108 @@ static VALUE rb_git_blob_to_buffer(int argc, VALUE *argv, VALUE self)
 	return rb_ret;
 }
 
+#define RUGGED_MERGE_FILE_INPUT_INIT { GIT_MERGE_FILE_INPUT_INIT }
+
+typedef struct {
+	git_merge_file_input parent;
+	int has_id;
+	git_oid id;
+} rugged_merge_file_input;
+
+static void rugged_parse_merge_file_input(rugged_merge_file_input *input, git_repository *repo, VALUE rb_input)
+{
+	VALUE rb_value;
+
+	Check_Type(rb_input, T_HASH);
+
+	if (!NIL_P(rb_value = rb_hash_aref(rb_input, CSTR2SYM("content")))) {
+		input->parent.ptr = RSTRING_PTR(rb_value);
+		input->parent.size = RSTRING_LEN(rb_value);
+	} else if (!NIL_P(rb_value = rb_hash_aref(rb_input, CSTR2SYM("oid")))) {
+		if (!repo)
+			rb_raise(rb_eArgError, "Rugged repository is required when file input is `:oid`.");
+
+		rugged_exception_check(git_oid_fromstr(&input->id, RSTRING_PTR(rb_value)));
+		input->has_id = 1;
+	} else {
+		rb_raise(rb_eArgError, "File input must have `:content` or `:oid`.");
+	}
+
+	rb_value = rb_hash_aref(rb_input, CSTR2SYM("filemode"));
+	if (!NIL_P(rb_value))
+		input->parent.mode = FIX2UINT(rb_value);
+
+	rb_value = rb_hash_aref(rb_input, CSTR2SYM("path"));
+	if (!NIL_P(rb_value)) {
+		Check_Type(rb_value, T_STRING);
+		input->parent.path = RSTRING_PTR(rb_value);
+	}
+}
+
+static int rugged_load_merge_file_input(git_blob **out, git_repository *repo, rugged_merge_file_input *input)
+{
+	int error;
+
+	if (!input->has_id)
+		return 0;
+
+	if ((error = git_blob_lookup(out, repo, &input->id)) < 0)
+		return error;
+
+	input->parent.ptr = git_blob_rawcontent(*out);
+	input->parent.size = git_blob_rawsize(*out);
+
+	return 0;
+}
+
+static VALUE rb_git_blob_merge_files(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE rb_repo, rb_ancestor, rb_ours, rb_theirs, rb_options, rb_result;
+
+	git_repository *repo = NULL;
+	rugged_merge_file_input ancestor = RUGGED_MERGE_FILE_INPUT_INIT,
+		ours = RUGGED_MERGE_FILE_INPUT_INIT,
+		theirs = RUGGED_MERGE_FILE_INPUT_INIT;
+	git_blob *ancestor_blob = NULL, *our_blob = NULL, *their_blob = NULL;
+	git_merge_file_options opts = GIT_MERGE_FILE_OPTIONS_INIT;
+	git_merge_file_result result = {0};
+	int error;
+
+	rb_scan_args(argc, argv, "41", &rb_repo, &rb_ancestor, &rb_ours, &rb_theirs, &rb_options);
+
+	if (!NIL_P(rb_repo)) {
+		rugged_check_repo(rb_repo);
+		Data_Get_Struct(rb_repo, git_repository, repo);
+	}
+
+	if (!NIL_P(rb_options))
+		rugged_parse_merge_file_options(&opts, rb_options);
+
+	if (!NIL_P(rb_ancestor))
+		rugged_parse_merge_file_input(&ancestor, repo, rb_ancestor);
+	if (!NIL_P(rb_ours))
+		rugged_parse_merge_file_input(&ours, repo, rb_ours);
+	if (!NIL_P(rb_theirs))
+		rugged_parse_merge_file_input(&theirs, repo, rb_theirs);
+
+	if ((error = rugged_load_merge_file_input(&ancestor_blob, repo, &ancestor)) < 0 ||
+		(error = rugged_load_merge_file_input(&our_blob, repo, &ours)) < 0 ||
+		(error = rugged_load_merge_file_input(&their_blob, repo, &theirs)) < 0 ||
+		(error = git_merge_file(&result, &ancestor.parent, &ours.parent, &theirs.parent, &opts)) < 0)
+		goto done;
+
+	rb_result = rb_merge_file_result_fromC(&result);
+
+done:
+	git_blob_free(ancestor_blob);
+	git_blob_free(our_blob);
+	git_blob_free(their_blob);
+	git_merge_file_result_free(&result);
+
+	rugged_exception_check(error);
+	return rb_result;
+}
+
 static VALUE rb_git_blob_sig_new(int argc, VALUE *argv, VALUE klass)
 {
 	int error, opts = 0;
@@ -622,6 +724,7 @@ void Init_rugged_blob(void)
 	rb_define_singleton_method(rb_cRuggedBlob, "from_io", rb_git_blob_from_io, -1);
 
 	rb_define_singleton_method(rb_cRuggedBlob, "to_buffer", rb_git_blob_to_buffer, -1);
+	rb_define_singleton_method(rb_cRuggedBlob, "merge_files", rb_git_blob_merge_files, -1);
 
 	rb_cRuggedBlobSig = rb_define_class_under(rb_cRuggedBlob, "HashSignature", rb_cObject);
 	rb_define_singleton_method(rb_cRuggedBlobSig, "new", rb_git_blob_sig_new, -1);

data/ext/rugged/rugged_index.c

@@ -952,76 +952,6 @@ static VALUE rb_git_conflict_get(VALUE self, VALUE rb_path)
 	return rb_result;
 }
 
-void rugged_parse_merge_file_options(git_merge_file_options *opts, VALUE rb_options)
-{
-	if (!NIL_P(rb_options)) {
-		VALUE rb_value;
-		Check_Type(rb_options, T_HASH);
-
-		rb_value = rb_hash_aref(rb_options, CSTR2SYM("ancestor_label"));
-		if (!NIL_P(rb_value)) {
-			Check_Type(rb_value, T_STRING);
-			opts->ancestor_label = StringValueCStr(rb_value);
-		}
-
-		rb_value = rb_hash_aref(rb_options, CSTR2SYM("our_label"));
-		if (!NIL_P(rb_value)) {
-			Check_Type(rb_value, T_STRING);
-			opts->our_label = StringValueCStr(rb_value);
-		}
-
-		rb_value = rb_hash_aref(rb_options, CSTR2SYM("their_label"));
-		if (!NIL_P(rb_value)) {
-			Check_Type(rb_value, T_STRING);
-			opts->their_label = StringValueCStr(rb_value);
-		}
-
-		rb_value = rb_hash_aref(rb_options, CSTR2SYM("favor"));
-		if (!NIL_P(rb_value)) {
-			ID id_favor;
-
-			Check_Type(rb_value, T_SYMBOL);
-			id_favor = SYM2ID(rb_value);
-
-			if (id_favor == rb_intern("normal")) {
-				opts->favor = GIT_MERGE_FILE_FAVOR_NORMAL;
-			} else if (id_favor == rb_intern("ours")) {
-				opts->favor = GIT_MERGE_FILE_FAVOR_OURS;
-			} else if (id_favor == rb_intern("theirs")) {
-				opts->favor = GIT_MERGE_FILE_FAVOR_THEIRS;
-			} else if (id_favor == rb_intern("union")) {
-				opts->favor = GIT_MERGE_FILE_FAVOR_UNION;
-			} else {
-				rb_raise(rb_eTypeError,
-					"Invalid favor mode. Expected `:normal`, `:ours`, `:theirs` or `:union`");
-			}
-		}
-
-		rb_value = rb_hash_aref(rb_options, CSTR2SYM("style"));
-		if (!NIL_P(rb_value)) {
-			ID id_style;
-
-			Check_Type(rb_value, T_SYMBOL);
-			id_style = SYM2ID(rb_value);
-
-			if (id_style == rb_intern("standard")) {
-				opts->flags |= GIT_MERGE_FILE_STYLE_MERGE;
-			} else if (id_style == rb_intern("diff3")) {
-				opts->flags |= GIT_MERGE_FILE_STYLE_DIFF3;
-			} else {
-				rb_raise(rb_eTypeError,
-					"Invalid style mode. Expected `:standard`, or `:diff3`");
-			}
-		} else {
-			opts->flags |= GIT_MERGE_FILE_STYLE_MERGE;
-		}
-
-		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("simplify")))) {
-			opts->flags |= GIT_MERGE_FILE_SIMPLIFY_ALNUM;
-		}
-	}
-}
-
 /*
  *  call-seq:
  *    index.merge_file(path[, options]) -> merge_file or nil
@@ -1061,8 +991,7 @@ void rugged_parse_merge_file_options(git_merge_file_options *opts, VALUE rb_opti
 
 static VALUE rb_git_merge_file(int argc, VALUE *argv, VALUE self)
 {
-	VALUE rb_path, rb_options;
-	VALUE rb_result = rb_hash_new();
+	VALUE rb_path, rb_options, rb_result;
 	VALUE rb_repo = rugged_owner(self);
 
 	git_repository *repo;
@@ -1074,10 +1003,8 @@ static VALUE rb_git_merge_file(int argc, VALUE *argv, VALUE self)
 
 	rb_scan_args(argc, argv, "1:", &rb_path, &rb_options);
 
-	if (!NIL_P(rb_options)) {
-		Check_Type(rb_options, T_HASH);
+	if (!NIL_P(rb_options))
 		rugged_parse_merge_file_options(&opts, rb_options);
-	}
 
 	Check_Type(rb_path, T_STRING);
 
@@ -1092,14 +1019,15 @@ static VALUE rb_git_merge_file(int argc, VALUE *argv, VALUE self)
 	else
 		rugged_exception_check(error);
 
+	if (ours == NULL)
+		rb_raise(rb_eRuntimeError, "The conflict does not have a stage 2 entry");
+	else if (theirs == NULL)
+		rb_raise(rb_eRuntimeError, "The conflict does not have a stage 3 entry");
+
 	error = git_merge_file_from_index(&merge_file_result, repo, ancestor, ours, theirs, &opts);
 	rugged_exception_check(error);
 
-	rb_hash_aset(rb_result, CSTR2SYM("automergeable"), merge_file_result.automergeable ? Qtrue : Qfalse);
-	rb_hash_aset(rb_result, CSTR2SYM("path"),         rb_path);
-	rb_hash_aset(rb_result, CSTR2SYM("filemode"),     INT2FIX(merge_file_result.mode));
-	rb_hash_aset(rb_result, CSTR2SYM("data"),         rb_str_new(merge_file_result.ptr, merge_file_result.len));
-
+	rb_result = rb_merge_file_result_fromC(&merge_file_result);
 	git_merge_file_result_free(&merge_file_result);
 
 	return rb_result;

data/ext/rugged/rugged_remote.c

@@ -29,8 +29,6 @@ extern VALUE rb_cRuggedRepo;
 extern VALUE rb_eRuggedError;
 VALUE rb_cRuggedRemote;
 
-#define RUGGED_REMOTE_CALLBACKS_INIT {1, progress_cb, NULL, credentials_cb, NULL, transfer_progress_cb, update_tips_cb, NULL, NULL, push_update_reference_cb, NULL}
-
 static int progress_cb(const char *str, int len, void *data)
 {
 	struct rugged_remote_cb_payload *payload = data;
@@ -96,6 +94,27 @@ static int update_tips_cb(const char *refname, const git_oid *src, const git_oid
 	return payload->exception ? GIT_ERROR : GIT_OK;
 }
 
+static int certificate_check_cb(git_cert *cert, int valid, const char *host, void *data)
+{
+	struct rugged_remote_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(3);
+	VALUE ret;
+
+	if (NIL_P(payload->certificate_check))
+		return valid ? 0 : GIT_ECERTIFICATE;
+
+	rb_ary_push(args, payload->certificate_check);
+	rb_ary_push(args, valid ? Qtrue : Qfalse);
+	rb_ary_push(args, rb_str_new_utf8(host));
+
+	ret = rb_protect(rugged__block_yield_splat, args, &payload->exception);
+
+	if (payload->exception)
+		return GIT_ERROR;
+
+	return rugged_parse_bool(ret) ? GIT_OK : GIT_ECERTIFICATE;
+}
+
 struct extract_cred_args
 {
 	VALUE rb_callback;
@@ -155,11 +174,9 @@ static int credentials_cb(
 	return payload->exception ? GIT_ERROR : GIT_OK;
 }
 
-#define CALLABLE_OR_RAISE(ret, rb_options, name) \
-	do {							\
-		ret = rb_hash_aref(rb_options, CSTR2SYM(name)); \
-								\
-		if (!NIL_P(ret) && !rb_respond_to(ret, rb_intern("call"))) \
+#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);
 
@@ -168,16 +185,39 @@ void rugged_remote_init_callbacks_and_payload_from_options(
 	git_remote_callbacks *callbacks,
 	struct rugged_remote_cb_payload *payload)
 {
-	git_remote_callbacks prefilled = RUGGED_REMOTE_CALLBACKS_INIT;
-
-	prefilled.payload = payload;
-	memcpy(callbacks, &prefilled, sizeof(git_remote_callbacks));
+	callbacks->payload = payload;
+	callbacks->push_update_reference = push_update_reference_cb;
 
 	if (!NIL_P(rb_options)) {
-		CALLABLE_OR_RAISE(payload->update_tips, rb_options, "update_tips");
-		CALLABLE_OR_RAISE(payload->progress, rb_options, "progress");
-		CALLABLE_OR_RAISE(payload->transfer_progress, rb_options, "transfer_progress");
-		CALLABLE_OR_RAISE(payload->credentials, rb_options, "credentials");
+		payload->progress = rb_hash_aref(rb_options, CSTR2SYM("progress"));
+		if (!NIL_P(payload->progress)) {
+			CALLABLE_OR_RAISE(payload->progress, "progress");
+			callbacks->sideband_progress = progress_cb;
+		}
+
+		payload->credentials = rb_hash_aref(rb_options, CSTR2SYM("credentials"));
+		if (!NIL_P(payload->credentials)) {
+			CALLABLE_OR_RAISE(payload->credentials, "credentials");
+			callbacks->credentials = credentials_cb;
+		}
+
+		payload->certificate_check = rb_hash_aref(rb_options, CSTR2SYM("certificate_check"));
+		if (!NIL_P(payload->certificate_check)) {
+			CALLABLE_OR_RAISE(payload->certificate_check, "certificate_check");
+			callbacks->certificate_check = certificate_check_cb;
+		}
+
+		payload->transfer_progress = rb_hash_aref(rb_options, CSTR2SYM("transfer_progress"));
+		if (!NIL_P(payload->transfer_progress)) {
+			CALLABLE_OR_RAISE(payload->transfer_progress, "transfer_progress");
+			callbacks->transfer_progress = transfer_progress_cb;
+		}
+
+		payload->update_tips = rb_hash_aref(rb_options, CSTR2SYM("update_tips"));
+		if (!NIL_P(payload->update_tips)) {
+			CALLABLE_OR_RAISE(payload->update_tips, "update_tips");
+			callbacks->update_tips = update_tips_cb;
+		}
 	}
 }
 
@@ -274,7 +314,7 @@ static VALUE rb_git_remote_ls(int argc, VALUE *argv, VALUE self)
 	git_strarray custom_headers = {0};
 	const git_remote_head **heads;
 
-	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
 
 	VALUE rb_options;
 
@@ -471,7 +511,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_strarray custom_headers = {0};
-	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
 	VALUE rb_direction, rb_options;
 	ID id_direction;
 	int error, direction;
@@ -537,6 +577,11 @@ static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
  *    A callback that will be executed each time a reference is updated locally. It will be
  *    passed the +refname+, +old_oid+ and +new_oid+.
  *
+ *  :certificate_check ::
+ *    A callback that will be executed each time we validate a certificate using https. It
+ *    will be passed the +valid+, +host_name+ and the callback should return a true/false to
+ *    indicate if the certificate has been validated.
+ *
  *  :message ::
  *    The message to insert into the reflogs. Defaults to "fetch".
  *
@@ -559,7 +604,7 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
 	git_strarray refspecs;
 	git_fetch_options opts = GIT_FETCH_OPTIONS_INIT;
 	const git_transfer_progress *stats;
-	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
 
 	char *log_message = NULL;
 	int error;
@@ -650,7 +695,7 @@ static VALUE rb_git_remote_push(int argc, VALUE *argv, VALUE self)
 
 	int error = 0;
 
-	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, rb_hash_new(), 0 };
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, rb_hash_new(), 0 };
 
 	rb_scan_args(argc, argv, "01:", &rb_refspecs, &rb_options);
 

data/ext/rugged/rugged_repo.c

@@ -485,7 +485,7 @@ static VALUE rb_git_repo_clone_at(int argc, VALUE *argv, VALUE klass)
 {
 	VALUE url, local_path, rb_options_hash;
 	git_clone_options options = GIT_CLONE_OPTIONS_INIT;
-	struct rugged_remote_cb_payload remote_payload = { Qnil, Qnil, Qnil, Qnil, 0 };
+	struct rugged_remote_cb_payload remote_payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
 	git_repository *repo;
 	int error;
 

data/lib/rugged/version.rb

@@ -1,3 +1,3 @@
 module Rugged
-  Version = VERSION = '0.25.0b8'
+  Version = VERSION = '0.25.0b9'
 end

data/vendor/libgit2/CMakeLists.txt

@@ -20,6 +20,7 @@ SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Mo
 
 INCLUDE(CheckLibraryExists)
 INCLUDE(CheckFunctionExists)
+INCLUDE(CheckSymbolExists)
 INCLUDE(CheckStructHasMember)
 INCLUDE(AddCFlagIfSupported)
 INCLUDE(FindPkgConfig)
@@ -286,6 +287,7 @@ ELSE ()
 	IF (CURL_FOUND)
 		ADD_DEFINITIONS(-DGIT_CURL)
 		INCLUDE_DIRECTORIES(${CURL_INCLUDE_DIRS})
+		LINK_DIRECTORIES(${CURL_LIBRARY_DIRS})
 		LINK_LIBRARIES(${CURL_LIBRARIES})
 		LIST(APPEND LIBGIT2_PC_LIBS ${CURL_LDFLAGS})
 	ENDIF()
@@ -506,6 +508,11 @@ ELSE ()
 	ENDIF ()
 ENDIF()
 
+CHECK_SYMBOL_EXISTS(regcomp_l "xlocale.h" HAVE_REGCOMP_L)
+IF (HAVE_REGCOMP_L)
+	ADD_DEFINITIONS(-DHAVE_REGCOMP_L)
+ENDIF ()
+
 CHECK_FUNCTION_EXISTS(futimens HAVE_FUTIMENS)
 IF (HAVE_FUTIMENS)
 	ADD_DEFINITIONS(-DHAVE_FUTIMENS)

data/vendor/libgit2/include/git2/diff.h

@@ -490,6 +490,14 @@ typedef struct {
 
 /** Structure describing the binary contents of a diff. */
 typedef struct {
+	/**
+	 * Whether there is data in this binary structure or not.  If this
+	 * is `1`, then this was produced and included binary content.  If
+	 * this is `0` then this was generated knowing only that a binary
+	 * file changed but without providing the data, probably from a patch
+	 * that said `Binary files a/file.txt and b/file.txt differ`.
+	 */
+	unsigned int contains_data;
 	git_diff_binary_file old_file; /**< The contents of the old file. */
 	git_diff_binary_file new_file; /**< The contents of the new file. */
 } git_diff_binary;

data/vendor/libgit2/include/git2/sys/time.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_git_time_h__
+#define INCLUDE_git_time_h__
+
+#include "git2/common.h"
+
+GIT_BEGIN_DECL
+
+/**
+ * Return a monotonic time value, useful for measuring running time
+ * and setting up timeouts.
+ *
+ * The returned value is an arbitrary point in time -- it can only be
+ * used when comparing it to another `git_time_monotonic` call.
+ *
+ * The time is returned in seconds, with a decimal fraction that differs
+ * on accuracy based on the underlying system, but should be least
+ * accurate to Nanoseconds.
+ *
+ * This function cannot fail.
+ */
+GIT_EXTERN(double) git_time_monotonic(void);
+
+GIT_END_DECL
+#endif
+

data/vendor/libgit2/src/apply.c

@@ -291,7 +291,15 @@ static int apply_binary(
 	git_patch *patch)
 {
 	git_buf reverse = GIT_BUF_INIT;
-	int error;
+	int error = 0;
+
+	if (!patch->binary.contains_data) {
+		error = apply_err("patch does not contain binary data");
+		goto done;
+	}
+
+	if (!patch->binary.old_file.datalen && !patch->binary.new_file.datalen)
+		goto done;
 
 	/* first, apply the new_file delta to the given source */
 	if ((error = apply_binary_delta(out, source, source_len,

data/vendor/libgit2/src/checkout.c

@@ -212,6 +212,10 @@ static bool checkout_is_workdir_modified(
 	if (baseitem->size && wditem->file_size != baseitem->size)
 		return true;
 
+	/* if the workdir item is a directory, it cannot be a modified file */
+	if (S_ISDIR(wditem->mode))
+		return false;
+
 	if (git_diff__oid_for_entry(&oid, data->diff, wditem, wditem->mode, NULL) < 0)
 		return false;
 

data/vendor/libgit2/src/config.c

@@ -478,7 +478,7 @@ int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cf
 	iter = git__calloc(1, sizeof(all_iter));
 	GITERR_CHECK_ALLOC(iter);
 
-	if ((result = regcomp(&iter->regex, regexp, REG_EXTENDED)) != 0) {
+	if ((result = p_regcomp(&iter->regex, regexp, REG_EXTENDED)) != 0) {
 		giterr_set_regex(&iter->regex, result);
 		git__free(iter);
 		return -1;
@@ -512,7 +512,7 @@ int git_config_backend_foreach_match(
 	int error = 0;
 
 	if (regexp != NULL) {
-		if ((error = regcomp(&regex, regexp, REG_EXTENDED)) != 0) {
+		if ((error = p_regcomp(&regex, regexp, REG_EXTENDED)) != 0) {
 			giterr_set_regex(&regex, error);
 			regfree(&regex);
 			return -1;
@@ -1003,7 +1003,7 @@ int git_config_multivar_iterator_new(git_config_iterator **out, const git_config
 		goto on_error;
 
 	if (regexp != NULL) {
-		error = regcomp(&iter->regex, regexp, REG_EXTENDED);
+		error = p_regcomp(&iter->regex, regexp, REG_EXTENDED);
 		if (error != 0) {
 			giterr_set_regex(&iter->regex, error);
 			error = -1;

data/vendor/libgit2/src/config_file.c

@@ -570,7 +570,7 @@ static int config_set_multivar(
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
-	result = regcomp(&preg, regexp, REG_EXTENDED);
+	result = p_regcomp(&preg, regexp, REG_EXTENDED);
 	if (result != 0) {
 		giterr_set_regex(&preg, result);
 		result = -1;
@@ -657,7 +657,7 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 
 	refcounted_strmap_free(map);
 
-	result = regcomp(&preg, regexp, REG_EXTENDED);
+	result = p_regcomp(&preg, regexp, REG_EXTENDED);
 	if (result != 0) {
 		giterr_set_regex(&preg, result);
 		result = -1;
@@ -1957,4 +1957,3 @@ done:
 	git_buf_free(&reader->buffer);
 	return result;
 }
-

data/vendor/libgit2/src/diff_driver.c

@@ -114,7 +114,7 @@ static int diff_driver_add_patterns(
 		if (error < 0)
 			break;
 
-		if ((error = regcomp(&pat->re, buf.ptr, regex_flags)) != 0) {
+		if ((error = p_regcomp(&pat->re, buf.ptr, regex_flags)) != 0) {
 			/*
 			 * TODO: issue a warning
 			 */
@@ -210,7 +210,7 @@ static int git_diff_driver_builtin(
 		goto done;
 
 	if (ddef->words &&
-		(error = regcomp(
+		(error = p_regcomp(
 			&drv->word_pattern, ddef->words, ddef->flags | REG_EXTENDED)))
 	{
 		error = giterr_set_regex(&drv->word_pattern, error);
@@ -314,7 +314,7 @@ static int git_diff_driver_load(
 		goto done;
 	if (!ce || !ce->value)
 		/* no diff.<driver>.wordregex, so just continue */;
-	else if (!(error = regcomp(&drv->word_pattern, ce->value, REG_EXTENDED)))
+	else if (!(error = p_regcomp(&drv->word_pattern, ce->value, REG_EXTENDED)))
 		found_driver = true;
 	else {
 		/* TODO: warn about bad regex instead of failure */
@@ -519,4 +519,3 @@ void git_diff_find_context_clear(git_diff_find_context_payload *payload)
 		payload->driver = NULL;
 	}
 }
-

data/vendor/libgit2/src/diff_print.c

@@ -500,7 +500,6 @@ static int diff_print_patch_file_binary_noshow(
 			&new_path, new_pfx, delta->new_file.path)) < 0)
 		goto done;
 
-
 	pi->line.num_lines = 1;
 	error = diff_delta_format_with_paths(
 		pi->buf, delta, "Binary files %s and %s differ\n",
@@ -521,13 +520,13 @@ static int diff_print_patch_file_binary(
 	size_t pre_binary_size;
 	int error;
 
-	if ((pi->flags & GIT_DIFF_SHOW_BINARY) == 0)
+	if (delta->status == GIT_DELTA_UNMODIFIED)
+		return 0;
+
+	if ((pi->flags & GIT_DIFF_SHOW_BINARY) == 0 || !binary->contains_data)
 		return diff_print_patch_file_binary_noshow(
 			pi, delta, old_pfx, new_pfx);
 
-	if (binary->new_file.datalen == 0 && binary->old_file.datalen == 0)
-		return 0;
-
 	pre_binary_size = pi->buf->size;
 	git_buf_printf(pi->buf, "GIT binary patch\n");
 	pi->line.num_lines++;
@@ -563,8 +562,11 @@ static int diff_print_patch_file(
 	bool binary = (delta->flags & GIT_DIFF_FLAG_BINARY) ||
 		(pi->flags & GIT_DIFF_FORCE_BINARY);
 	bool show_binary = !!(pi->flags & GIT_DIFF_SHOW_BINARY);
-	int id_strlen = binary && show_binary ?
-		GIT_OID_HEXSZ : pi->id_strlen;
+	int id_strlen = pi->id_strlen;
+
+	if (binary && show_binary)
+		id_strlen = delta->old_file.id_abbrev ? delta->old_file.id_abbrev :
+			delta->new_file.id_abbrev;
 
 	GIT_UNUSED(progress);
 

data/vendor/libgit2/src/patch.c

@@ -17,6 +17,9 @@ int git_patch__invoke_callbacks(
 	if (file_cb)
 		error = file_cb(patch->delta, 0, payload);
 
+	if (error)
+		return error;
+
 	if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0) {
 		if (binary_cb)
 			error = binary_cb(patch->delta, &patch->binary, payload);

data/vendor/libgit2/src/patch_generate.c

@@ -342,7 +342,7 @@ done:
 
 static int diff_binary(git_patch_generated_output *output, git_patch_generated *patch)
 {
-	git_diff_binary binary = {{0}};
+	git_diff_binary binary = {0};
 	const char *old_data = patch->ofile.map.data;
 	const char *new_data = patch->nfile.map.data;
 	size_t old_len = patch->ofile.map.len,
@@ -352,6 +352,8 @@ static int diff_binary(git_patch_generated_output *output, git_patch_generated *
 	/* Only load contents if the user actually wants to diff
 	 * binary files. */
 	if (patch->base.diff_opts.flags & GIT_DIFF_SHOW_BINARY) {
+		binary.contains_data = 1;
+
 		/* Create the old->new delta (as the "new" side of the patch),
 		 * and the new->old delta (as the "old" side)
 		 */
@@ -492,8 +494,17 @@ static int diff_single_generate(patch_generated_with_delta *pd, git_xdiff_output
 	patch_generated_init_common(patch);
 
 	if (pd->delta.status == GIT_DELTA_UNMODIFIED &&
-		!(patch->ofile.opts_flags & GIT_DIFF_INCLUDE_UNMODIFIED))
+		!(patch->ofile.opts_flags & GIT_DIFF_INCLUDE_UNMODIFIED)) {
+
+		/* Even empty patches are flagged as binary, and even though
+		 * there's no difference, we flag this as "containing data"
+		 * (the data is known to be empty, as opposed to wholly unknown).
+		 */
+		if (patch->base.diff_opts.flags & GIT_DIFF_SHOW_BINARY)
+			patch->base.binary.contains_data = 1;
+
 		return error;
+	}
 
 	error = patch_generated_invoke_file_callback(patch, (git_patch_generated_output *)xo);
 

data/vendor/libgit2/src/patch_parse.c

@@ -74,8 +74,8 @@ static int parse_advance_expected(
 	return 0;
 }
 
-#define parse_advance_expected_s(ctx, str) \
-	parse_advance_expected(ctx, str, sizeof(str) - 1)
+#define parse_advance_expected_str(ctx, str) \
+	parse_advance_expected(ctx, str, strlen(str))
 
 static int parse_advance_ws(git_patch_parse_ctx *ctx)
 {
@@ -220,7 +220,7 @@ static int parse_header_git_index(
 {
 	if (parse_header_oid(&patch->base.delta->old_file.id,
 			&patch->base.delta->old_file.id_abbrev, ctx) < 0 ||
-		parse_advance_expected_s(ctx, "..") < 0 ||
+		parse_advance_expected_str(ctx, "..") < 0 ||
 		parse_header_oid(&patch->base.delta->new_file.id,
 			&patch->base.delta->new_file.id_abbrev, ctx) < 0)
 		return -1;
@@ -336,7 +336,7 @@ static int parse_header_percent(uint16_t *out, git_patch_parse_ctx *ctx)
 
 	parse_advance_chars(ctx, (end - ctx->line));
 
-	if (parse_advance_expected_s(ctx, "%") < 0)
+	if (parse_advance_expected_str(ctx, "%") < 0)
 		return -1;
 
 	if (val > 100)
@@ -379,6 +379,7 @@ static const header_git_op header_git_ops[] = {
 	{ "diff --git ", NULL },
 	{ "@@ -", NULL },
 	{ "GIT binary patch", NULL },
+	{ "Binary files ", NULL },
 	{ "--- ", parse_header_git_oldpath },
 	{ "+++ ", parse_header_git_newpath },
 	{ "index ", parse_header_git_index },
@@ -404,7 +405,7 @@ static int parse_header_git(
 	int error = 0;
 
 	/* Parse the diff --git line */
-	if (parse_advance_expected_s(ctx, "diff --git ") < 0)
+	if (parse_advance_expected_str(ctx, "diff --git ") < 0)
 		return parse_err("corrupt git diff header at line %d", ctx->line_num);
 
 	if (parse_header_path(&patch->header_old_path, ctx) < 0)
@@ -443,7 +444,7 @@ static int parse_header_git(
 				goto done;
 
 			parse_advance_ws(ctx);
-			parse_advance_expected_s(ctx, "\n");
+			parse_advance_expected_str(ctx, "\n");
 
 			if (ctx->line_len > 0) {
 				error = parse_err("trailing data at line %d", ctx->line_num);
@@ -505,27 +506,27 @@ static int parse_hunk_header(
 	hunk->hunk.old_lines = 1;
 	hunk->hunk.new_lines = 1;
 
-	if (parse_advance_expected_s(ctx, "@@ -") < 0 ||
+	if (parse_advance_expected_str(ctx, "@@ -") < 0 ||
 		parse_int(&hunk->hunk.old_start, ctx) < 0)
 		goto fail;
 
 	if (ctx->line_len > 0 && ctx->line[0] == ',') {
-		if (parse_advance_expected_s(ctx, ",") < 0 ||
+		if (parse_advance_expected_str(ctx, ",") < 0 ||
 			parse_int(&hunk->hunk.old_lines, ctx) < 0)
 			goto fail;
 	}
 
-	if (parse_advance_expected_s(ctx, " +") < 0 ||
+	if (parse_advance_expected_str(ctx, " +") < 0 ||
 		parse_int(&hunk->hunk.new_start, ctx) < 0)
 		goto fail;
 
 	if (ctx->line_len > 0 && ctx->line[0] == ',') {
-		if (parse_advance_expected_s(ctx, ",") < 0 ||
+		if (parse_advance_expected_str(ctx, ",") < 0 ||
 			parse_int(&hunk->hunk.new_lines, ctx) < 0)
 			goto fail;
 	}
 
-	if (parse_advance_expected_s(ctx, " @@") < 0)
+	if (parse_advance_expected_str(ctx, " @@") < 0)
 		goto fail;
 
 	parse_advance_line(ctx);
@@ -782,7 +783,7 @@ static int parse_patch_binary(
 {
 	int error;
 
-	if (parse_advance_expected_s(ctx, "GIT binary patch") < 0 ||
+	if (parse_advance_expected_str(ctx, "GIT binary patch") < 0 ||
 		parse_advance_nl(ctx) < 0)
 		return parse_err("corrupt git binary header at line %d", ctx->line_num);
 
@@ -804,6 +805,24 @@ static int parse_patch_binary(
 		return parse_err("corrupt git binary patch separator at line %d",
 			ctx->line_num);
 
+	patch->base.binary.contains_data = 1;
+	patch->base.delta->flags |= GIT_DIFF_FLAG_BINARY;
+	return 0;
+}
+
+static int parse_patch_binary_nodata(
+	git_patch_parsed *patch,
+	git_patch_parse_ctx *ctx)
+{
+	if (parse_advance_expected_str(ctx, "Binary files ") < 0 ||
+		parse_advance_expected_str(ctx, patch->header_old_path) < 0 ||
+		parse_advance_expected_str(ctx, " and ") < 0 ||
+		parse_advance_expected_str(ctx, patch->header_new_path) < 0 ||
+		parse_advance_expected_str(ctx, " differ") < 0 ||
+		parse_advance_nl(ctx) < 0)
+		return parse_err("corrupt git binary header at line %d", ctx->line_num);
+
+	patch->base.binary.contains_data = 0;
 	patch->base.delta->flags |= GIT_DIFF_FLAG_BINARY;
 	return 0;
 }
@@ -840,6 +859,8 @@ static int parse_patch_body(
 {
 	if (parse_ctx_contains_s(ctx, "GIT binary patch"))
 		return parse_patch_binary(patch, ctx);
+	else if (parse_ctx_contains_s(ctx, "Binary files "))
+		return parse_patch_binary_nodata(patch, ctx);
 	else
 		return parse_patch_hunks(patch, ctx);
 }

data/vendor/libgit2/src/refspec.c

@@ -53,8 +53,10 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 
 	if (rhs) {
 		size_t rlen = strlen(++rhs);
-		is_glob = (1 <= rlen && strchr(rhs, '*'));
-		refspec->dst = git__strndup(rhs, rlen);
+		if (rlen || !is_fetch) {
+			is_glob = (1 <= rlen && strchr(rhs, '*'));
+			refspec->dst = git__strndup(rhs, rlen);
+		}
 	}
 
 	llen = (rhs ? (size_t)(rhs - lhs - 1) : strlen(lhs));

data/vendor/libgit2/src/revparse.c

@@ -50,7 +50,7 @@ static int build_regex(regex_t *regex, const char *pattern)
 		return GIT_EINVALIDSPEC;
 	}
 
-	error = regcomp(regex, pattern, REG_EXTENDED);
+	error = p_regcomp(regex, pattern, REG_EXTENDED);
 	if (!error)
 		return 0;
 

data/vendor/libgit2/src/unix/posix.h

@@ -80,4 +80,14 @@ GIT_INLINE(int) p_futimes(int f, const struct p_timeval t[2])
 # define p_futimes futimes
 #endif
 
+#ifdef HAVE_REGCOMP_L
+#include <xlocale.h>
+GIT_INLINE(int) p_regcomp(regex_t *preg, const char *pattern, int cflags)
+{
+	return regcomp_l(preg, pattern, cflags, (locale_t) 0);
+}
+#else
+# define p_regcomp regcomp
+#endif
+
 #endif

data/vendor/libgit2/src/util.c

@@ -783,6 +783,11 @@ int git__utf8_iterate(const uint8_t *str, int str_len, int32_t *dst)
 	return length;
 }
 
+double git_time_monotonic(void)
+{
+	return git__timer();
+}
+
 #ifdef GIT_WIN32
 int git__getenv(git_buf *out, const char *name)
 {

data/vendor/libgit2/src/win32/posix.h

@@ -57,4 +57,7 @@ extern int p_lstat_posixly(const char *filename, struct stat *buf);
 extern struct tm * p_localtime_r(const time_t *timer, struct tm *result);
 extern struct tm * p_gmtime_r(const time_t *timer, struct tm *result);
 
+/* Use the bundled regcomp */
+#define p_regcomp regcomp
+
 #endif

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rugged
 version: !ruby/object:Gem::Version
-  version: 0.25.0b8
+  version: 0.25.0b9
 platform: ruby
 authors:
 - Scott Chacon
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-02 00:00:00.000000000 Z
+date: 2016-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -231,6 +231,7 @@ files:
 - vendor/libgit2/include/git2/sys/remote.h
 - vendor/libgit2/include/git2/sys/repository.h
 - vendor/libgit2/include/git2/sys/stream.h
+- vendor/libgit2/include/git2/sys/time.h
 - vendor/libgit2/include/git2/sys/transport.h
 - vendor/libgit2/include/git2/tag.h
 - vendor/libgit2/include/git2/trace.h