rugged 1.6.3 → 1.9.0

data/vendor/libgit2/src/libgit2/diff_generate.c

@@ -61,8 +61,8 @@ static git_diff_delta *diff_delta__alloc(
 	}
 	delta->status = status;
 
-	git_oid_clear(&delta->old_file.id, GIT_OID_SHA1);
-	git_oid_clear(&delta->new_file.id, GIT_OID_SHA1);
+	git_oid_clear(&delta->old_file.id, diff->base.opts.oid_type);
+	git_oid_clear(&delta->new_file.id, diff->base.opts.oid_type);
 
 	return delta;
 }
@@ -149,10 +149,13 @@ static int diff_delta__from_one(
 	const git_index_entry *entry = nitem;
 	bool has_old = false;
 	git_diff_delta *delta;
+	git_oid_t oid_type;
 	const char *matched_pathspec;
 
 	GIT_ASSERT_ARG((oitem != NULL) ^ (nitem != NULL));
 
+	oid_type = diff->base.opts.oid_type;
+
 	if (oitem) {
 		entry = oitem;
 		has_old = true;
@@ -186,20 +189,23 @@ static int diff_delta__from_one(
 	GIT_ASSERT(status != GIT_DELTA_MODIFIED);
 	delta->nfiles = 1;
 
+	git_oid_clear(&delta->old_file.id, diff->base.opts.oid_type);
+	git_oid_clear(&delta->new_file.id, diff->base.opts.oid_type);
+
 	if (has_old) {
 		delta->old_file.mode = entry->mode;
 		delta->old_file.size = entry->file_size;
 		delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS;
 		git_oid_cpy(&delta->old_file.id, &entry->id);
-		git_oid_clear(&delta->new_file.id, GIT_OID_SHA1);
-		delta->old_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+		git_oid_clear(&delta->new_file.id, oid_type);
+		delta->old_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
 	} else /* ADDED, IGNORED, UNTRACKED */ {
 		delta->new_file.mode = entry->mode;
 		delta->new_file.size = entry->file_size;
 		delta->new_file.flags |= GIT_DIFF_FLAG_EXISTS;
-		git_oid_clear(&delta->old_file.id, GIT_OID_SHA1);
+		git_oid_clear(&delta->old_file.id, oid_type);
 		git_oid_cpy(&delta->new_file.id, &entry->id);
-		delta->new_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+		delta->new_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
 	}
 
 	delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
@@ -225,6 +231,9 @@ static int diff_delta__from_two(
 	const git_oid *old_id = &old_entry->id;
 	git_diff_delta *delta;
 	const char *canonical_path = old_entry->path;
+	git_oid_t oid_type;
+
+	oid_type = diff->base.opts.oid_type;
 
 	if (status == GIT_DELTA_UNMODIFIED &&
 		DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_UNMODIFIED))
@@ -254,14 +263,14 @@ static int diff_delta__from_two(
 		delta->old_file.size = old_entry->file_size;
 		delta->old_file.mode = old_mode;
 		git_oid_cpy(&delta->old_file.id, old_id);
-		delta->old_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+		delta->old_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
 		delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID |
 			GIT_DIFF_FLAG_EXISTS;
 	}
 
 	if (!git_index_entry_is_conflict(new_entry)) {
 		git_oid_cpy(&delta->new_file.id, new_id);
-		delta->new_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+		delta->new_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
 		delta->new_file.size = new_entry->file_size;
 		delta->new_file.mode = new_mode;
 		delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS;
@@ -420,7 +429,7 @@ static void diff_generated_free(git_diff *d)
 	git_diff_generated *diff = (git_diff_generated *)d;
 
 	git_attr_session__free(&diff->base.attrsession);
-	git_vector_free_deep(&diff->base.deltas);
+	git_vector_dispose_deep(&diff->base.deltas);
 
 	git_pathspec__vfree(&diff->pathspec);
 	git_pool_clear(&diff->base.pool);
@@ -490,6 +499,14 @@ static int diff_generated_apply_options(
 			return -1;
 	}
 
+	if (!diff->base.opts.oid_type) {
+		diff->base.opts.oid_type = repo->oid_type;
+	} else if (diff->base.opts.oid_type != repo->oid_type) {
+		git_error_set(GIT_ERROR_INVALID,
+			"specified object ID type does not match repository object ID type");
+		return -1;
+	}
+
 	/* flag INCLUDE_TYPECHANGE_TREES implies INCLUDE_TYPECHANGE */
 	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_TYPECHANGE_TREES))
 		diff->base.opts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE;
@@ -603,7 +620,7 @@ int git_diff__oid_for_file(
 	entry.mode = mode;
 	entry.file_size = (uint32_t)size;
 	entry.path = (char *)path;
-	git_oid_clear(&entry.id, GIT_OID_SHA1);
+	git_oid_clear(&entry.id, diff->opts.oid_type);
 
 	return git_diff__oid_for_entry(out, diff, &entry, mode, NULL);
 }
@@ -624,7 +641,7 @@ int git_diff__oid_for_entry(
 	GIT_ASSERT(d->type == GIT_DIFF_TYPE_GENERATED);
 	diff = (git_diff_generated *)d;
 
-	git_oid_clear(out, GIT_OID_SHA1);
+	git_oid_clear(out, diff->base.opts.oid_type);
 
 	if (git_repository_workdir_path(&full_path, diff->base.repo, entry.path) < 0)
 		return -1;
@@ -660,7 +677,8 @@ int git_diff__oid_for_entry(
 			git_error_clear();
 		}
 	} else if (S_ISLNK(mode)) {
-		error = git_odb__hashlink(out, full_path.ptr, GIT_OID_SHA1);
+		error = git_odb__hashlink(out, full_path.ptr,
+			diff->base.opts.oid_type);
 		diff->base.perf.oid_calculations++;
 	} else if (!git__is_sizet(entry.file_size)) {
 		git_error_set(GIT_ERROR_NOMEMORY, "file size overflow (for 32-bits) on '%s'",
@@ -676,7 +694,8 @@ int git_diff__oid_for_entry(
 		else {
 			error = git_odb__hashfd_filtered(
 				out, fd, (size_t)entry.file_size,
-				GIT_OBJECT_BLOB, GIT_OID_SHA1, fl);
+				GIT_OBJECT_BLOB, diff->base.opts.oid_type,
+				fl);
 			p_close(fd);
 			diff->base.perf.oid_calculations++;
 		}
@@ -710,7 +729,7 @@ typedef struct {
 	git_iterator *new_iter;
 	const git_index_entry *oitem;
 	const git_index_entry *nitem;
-	git_strmap *submodule_cache;
+	git_submodule_cache *submodule_cache;
 	bool submodule_cache_initialized;
 } diff_in_progress;
 
@@ -726,7 +745,7 @@ static int maybe_modified_submodule(
 	git_submodule *sub;
 	unsigned int sm_status = 0;
 	git_submodule_ignore_t ign = diff->base.opts.ignore_submodules;
-	git_strmap *submodule_cache = NULL;
+	git_submodule_cache *submodule_cache = NULL;
 
 	*status = GIT_DELTA_UNMODIFIED;
 
@@ -785,7 +804,7 @@ static int maybe_modified(
 	git_diff_generated *diff,
 	diff_in_progress *info)
 {
-	git_oid noid = GIT_OID_SHA1_ZERO;
+	git_oid noid;
 	git_delta_t status = GIT_DELTA_MODIFIED;
 	const git_index_entry *oitem = info->oitem;
 	const git_index_entry *nitem = info->nitem;
@@ -796,6 +815,8 @@ static int maybe_modified(
 	const char *matched_pathspec;
 	int error = 0;
 
+	git_oid_clear(&noid, diff->base.opts.oid_type);
+
 	if (!diff_pathspec_match(&matched_pathspec, diff, oitem))
 		return 0;
 
@@ -1700,11 +1721,11 @@ int git_diff__commit(
 	*out = NULL;
 
 	if ((parents = git_commit_parentcount(commit)) > 1) {
-		char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
+		char commit_oidstr[GIT_OID_MAX_HEXSIZE + 1];
 
 		error = -1;
 		git_error_set(GIT_ERROR_INVALID, "commit %s is a merge commit",
-			git_oid_tostr(commit_oidstr, GIT_OID_SHA1_HEXSIZE + 1, git_commit_id(commit)));
+			git_oid_tostr(commit_oidstr, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit)));
 		goto on_error;
 	}
 

data/vendor/libgit2/src/libgit2/diff_parse.c

@@ -20,16 +20,16 @@ static void diff_parsed_free(git_diff *d)
 	git_vector_foreach(&diff->patches, i, patch)
 		git_patch_free(patch);
 
-	git_vector_free(&diff->patches);
+	git_vector_dispose(&diff->patches);
 
-	git_vector_free(&diff->base.deltas);
+	git_vector_dispose(&diff->base.deltas);
 	git_pool_clear(&diff->base.pool);
 
 	git__memzero(diff, sizeof(*diff));
 	git__free(diff);
 }
 
-static git_diff_parsed *diff_parsed_alloc(void)
+static git_diff_parsed *diff_parsed_alloc(git_oid_t oid_type)
 {
 	git_diff_parsed *diff;
 
@@ -51,6 +51,7 @@ static git_diff_parsed *diff_parsed_alloc(void)
 	}
 
 	diff->base.opts.flags &= ~GIT_DIFF_IGNORE_CASE;
+	diff->base.opts.oid_type = oid_type;
 
 	if (git_pool_init(&diff->base.pool, 1) < 0 ||
 	    git_vector_init(&diff->patches, 0, NULL) < 0 ||
@@ -67,19 +68,34 @@ static git_diff_parsed *diff_parsed_alloc(void)
 int git_diff_from_buffer(
 	git_diff **out,
 	const char *content,
-	size_t content_len)
+	size_t content_len
+#ifdef GIT_EXPERIMENTAL_SHA256
+	, git_diff_parse_options *opts
+#endif
+	)
 {
 	git_diff_parsed *diff;
 	git_patch *patch;
 	git_patch_parse_ctx *ctx = NULL;
+	git_patch_options patch_opts = GIT_PATCH_OPTIONS_INIT;
+	git_oid_t oid_type;
 	int error = 0;
 
 	*out = NULL;
 
-	diff = diff_parsed_alloc();
+#ifdef GIT_EXPERIMENTAL_SHA256
+	oid_type = (opts && opts->oid_type) ? opts->oid_type :
+		GIT_OID_DEFAULT;
+#else
+	oid_type = GIT_OID_DEFAULT;
+#endif
+
+	patch_opts.oid_type = oid_type;
+
+	diff = diff_parsed_alloc(oid_type);
 	GIT_ERROR_CHECK_ALLOC(diff);
 
-	ctx = git_patch_parse_ctx_init(content, content_len, NULL);
+	ctx = git_patch_parse_ctx_init(content, content_len, &patch_opts);
 	GIT_ERROR_CHECK_ALLOC(ctx);
 
 	while (ctx->parse_ctx.remain_len) {

data/vendor/libgit2/src/libgit2/diff_print.c

@@ -15,6 +15,7 @@
 #include "zstream.h"
 #include "blob.h"
 #include "delta.h"
+#include "repository.h"
 #include "git2/sys/diff.h"
 
 typedef struct {
@@ -29,6 +30,8 @@ typedef struct {
 	const char *new_prefix;
 	uint32_t flags;
 	int id_strlen;
+	unsigned int sent_file_header;
+	git_oid_t oid_type;
 
 	int (*strcomp)(const char *, const char *);
 } diff_print_info;
@@ -46,16 +49,15 @@ static int diff_print_info_init__common(
 	pi->payload = payload;
 	pi->buf = out;
 
+	GIT_ASSERT(pi->oid_type);
+
 	if (!pi->id_strlen) {
 		if (!repo)
 			pi->id_strlen = GIT_ABBREV_DEFAULT;
-		else if (git_repository__configmap_lookup(&pi->id_strlen, repo, GIT_CONFIGMAP_ABBREV) < 0)
+		else if (git_repository__abbrev_length(&pi->id_strlen, repo) < 0)
 			return -1;
 	}
 
-	if (pi->id_strlen > GIT_OID_SHA1_HEXSIZE)
-		pi->id_strlen = GIT_OID_SHA1_HEXSIZE;
-
 	memset(&pi->line, 0, sizeof(pi->line));
 	pi->line.old_lineno = -1;
 	pi->line.new_lineno = -1;
@@ -78,6 +80,7 @@ static int diff_print_info_init_fromdiff(
 
 	if (diff) {
 		pi->flags = diff->opts.flags;
+		pi->oid_type = diff->opts.oid_type;
 		pi->id_strlen = diff->opts.id_abbrev;
 		pi->old_prefix = diff->opts.old_prefix;
 		pi->new_prefix = diff->opts.new_prefix;
@@ -101,6 +104,7 @@ static int diff_print_info_init_frompatch(
 	memset(pi, 0, sizeof(diff_print_info));
 
 	pi->flags = patch->diff_opts.flags;
+	pi->oid_type = patch->diff_opts.oid_type;
 	pi->id_strlen = patch->diff_opts.id_abbrev;
 	pi->old_prefix = patch->diff_opts.old_prefix;
 	pi->new_prefix = patch->diff_opts.new_prefix;
@@ -212,7 +216,10 @@ static int diff_print_one_raw(
 	git_str *out = pi->buf;
 	int id_abbrev;
 	char code = git_diff_status_char(delta->status);
-	char start_oid[GIT_OID_SHA1_HEXSIZE+1], end_oid[GIT_OID_SHA1_HEXSIZE+1];
+	char start_oid[GIT_OID_MAX_HEXSIZE + 1],
+	     end_oid[GIT_OID_MAX_HEXSIZE + 1];
+	size_t oid_hexsize;
+	bool id_is_abbrev;
 
 	GIT_UNUSED(progress);
 
@@ -231,12 +238,21 @@ static int diff_print_one_raw(
 		return -1;
 	}
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	GIT_ASSERT(delta->old_file.id.type == delta->new_file.id.type);
+	oid_hexsize = git_oid_hexsize(delta->old_file.id.type);
+#else
+	oid_hexsize = GIT_OID_SHA1_HEXSIZE;
+#endif
+
+	id_is_abbrev = (pi->id_strlen > 0 &&
+	                (size_t)pi->id_strlen <= oid_hexsize);
+
 	git_oid_tostr(start_oid, pi->id_strlen + 1, &delta->old_file.id);
 	git_oid_tostr(end_oid, pi->id_strlen + 1, &delta->new_file.id);
 
-	git_str_printf(
-		out, (pi->id_strlen <= GIT_OID_SHA1_HEXSIZE) ?
-			":%06o %06o %s... %s... %c" : ":%06o %06o %s %s %c",
+	git_str_printf(out,
+		id_is_abbrev ? ":%06o %06o %s... %s... %c" : ":%06o %06o %s %s %c",
 		delta->old_file.mode, delta->new_file.mode, start_oid, end_oid, code);
 
 	if (delta->similarity > 0)
@@ -273,7 +289,8 @@ static int diff_print_oid_range(
 	git_str *out, const git_diff_delta *delta, int id_strlen,
 	bool print_index)
 {
-	char start_oid[GIT_OID_SHA1_HEXSIZE+1], end_oid[GIT_OID_SHA1_HEXSIZE+1];
+	char start_oid[GIT_OID_MAX_HEXSIZE + 1],
+	     end_oid[GIT_OID_MAX_HEXSIZE + 1];
 
 	if (delta->old_file.mode &&
 			id_strlen > delta->old_file.id_abbrev) {
@@ -560,6 +577,30 @@ static int diff_print_patch_file_binary(
 	return error;
 }
 
+GIT_INLINE(int) should_force_header(const git_diff_delta *delta)
+{
+	if (delta->old_file.mode != delta->new_file.mode)
+		return 1;
+
+	if (delta->status == GIT_DELTA_RENAMED || delta->status == GIT_DELTA_COPIED)
+		return 1;
+
+	return 0;
+}
+
+GIT_INLINE(int) flush_file_header(const git_diff_delta *delta, diff_print_info *pi)
+{
+	if (pi->sent_file_header)
+		return 0;
+
+	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
+	pi->line.content     = git_str_cstr(pi->buf);
+	pi->line.content_len = git_str_len(pi->buf);
+	pi->sent_file_header = 1;
+
+	return pi->print_cb(delta, NULL, &pi->line, pi->payload);
+}
+
 static int diff_print_patch_file(
 	const git_diff_delta *delta, float progress, void *data)
 {
@@ -590,15 +631,22 @@ static int diff_print_patch_file(
 		 (pi->flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) == 0))
 		return 0;
 
+	pi->sent_file_header = 0;
+
 	if ((error = git_diff_delta__format_file_header(pi->buf, delta, oldpfx, newpfx,
 							id_strlen, print_index)) < 0)
 		return error;
 
-	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
-	pi->line.content     = git_str_cstr(pi->buf);
-	pi->line.content_len = git_str_len(pi->buf);
+	/*
+	 * pi->buf now contains the file header data. Go ahead and send it
+	 * if there's useful data in there, like similarity. Otherwise, we
+	 * should queue it to send when we see the first hunk. This prevents
+	 * us from sending a header when all hunks were ignored.
+	 */
+	if (should_force_header(delta) && (error = flush_file_header(delta, pi)) < 0)
+		return error;
 
-	return pi->print_cb(delta, NULL, &pi->line, pi->payload);
+	return 0;
 }
 
 static int diff_print_patch_binary(
@@ -613,6 +661,16 @@ static int diff_print_patch_binary(
 		pi->new_prefix ? pi->new_prefix : DIFF_NEW_PREFIX_DEFAULT;
 	int error;
 
+	if ((error = flush_file_header(delta, pi)) < 0)
+		return error;
+
+	/*
+	 * If the caller only wants the header, we just needed to make sure to
+	 * call flush_file_header
+	 */
+	if (pi->format == GIT_DIFF_FORMAT_PATCH_HEADER)
+		return 0;
+
 	git_str_clear(pi->buf);
 
 	if ((error = diff_print_patch_file_binary(
@@ -632,10 +690,21 @@ static int diff_print_patch_hunk(
 	void *data)
 {
 	diff_print_info *pi = data;
+	int error;
 
 	if (S_ISDIR(d->new_file.mode))
 		return 0;
 
+	if ((error = flush_file_header(d, pi)) < 0)
+		return error;
+
+	/*
+	 * If the caller only wants the header, we just needed to make sure to
+	 * call flush_file_header
+	 */
+	if (pi->format == GIT_DIFF_FORMAT_PATCH_HEADER)
+		return 0;
+
 	pi->line.origin      = GIT_DIFF_LINE_HUNK_HDR;
 	pi->line.content     = h->header;
 	pi->line.content_len = h->header_len;
@@ -650,10 +719,14 @@ static int diff_print_patch_line(
 	void *data)
 {
 	diff_print_info *pi = data;
+	int error;
 
 	if (S_ISDIR(delta->new_file.mode))
 		return 0;
 
+	if ((error = flush_file_header(delta, pi)) < 0)
+		return error;
+
 	return pi->print_cb(delta, hunk, line, pi->payload);
 }
 
@@ -686,6 +759,8 @@ int git_diff_print(
 		break;
 	case GIT_DIFF_FORMAT_PATCH_HEADER:
 		print_file = diff_print_patch_file;
+		print_binary = diff_print_patch_binary;
+		print_hunk = diff_print_patch_hunk;
 		break;
 	case GIT_DIFF_FORMAT_RAW:
 		print_file = diff_print_one_raw;

data/vendor/libgit2/src/libgit2/diff_tform.c

@@ -190,7 +190,7 @@ int git_diff__merge(
 			git_pool_strdup_safe(&onto->pool, onto->opts.new_prefix);
 	}
 
-	git_vector_free_deep(&onto_new);
+	git_vector_dispose_deep(&onto_new);
 	git_pool_clear(&onto_pool);
 
 	return error;
@@ -364,7 +364,7 @@ static int insert_delete_side_of_split(
 	memset(&deleted->new_file, 0, sizeof(deleted->new_file));
 	deleted->new_file.path = deleted->old_file.path;
 	deleted->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
-	git_oid_clear(&deleted->new_file.id, GIT_OID_SHA1);
+	git_oid_clear(&deleted->new_file.id, diff->opts.oid_type);
 
 	return git_vector_insert(onto, deleted);
 }
@@ -398,7 +398,7 @@ static int apply_splits_and_deletes(
 			memset(&delta->old_file, 0, sizeof(delta->old_file));
 			delta->old_file.path = delta->new_file.path;
 			delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
-			git_oid_clear(&delta->old_file.id, GIT_OID_SHA1);
+			git_oid_clear(&delta->old_file.id, diff->opts.oid_type);
 		}
 
 		/* clean up delta before inserting into new list */
@@ -424,13 +424,13 @@ static int apply_splits_and_deletes(
 
 	/* swap new delta list into place */
 	git_vector_swap(&diff->deltas, &onto);
-	git_vector_free(&onto);
+	git_vector_dispose(&onto);
 	git_vector_sort(&diff->deltas);
 
 	return 0;
 
 on_error:
-	git_vector_free_deep(&onto);
+	git_vector_dispose_deep(&onto);
 
 	return -1;
 }
@@ -653,6 +653,23 @@ static int calc_self_similarity(
 	return 0;
 }
 
+static void handle_non_blob(
+	git_diff *diff,
+	const git_diff_find_options *opts,
+	size_t delta_idx)
+{
+	git_diff_delta *delta = GIT_VECTOR_GET(&diff->deltas, delta_idx);
+
+	/* skip things that are blobs */
+	if (GIT_MODE_ISBLOB(delta->old_file.mode))
+		return;
+
+	/* honor "remove unmodified" flag for non-blobs (eg submodules) */
+	if (delta->status == GIT_DELTA_UNMODIFIED &&
+	    FLAG_SET(opts, GIT_DIFF_FIND_REMOVE_UNMODIFIED))
+		delta->flags |= GIT_DIFF_FLAG__TO_DELETE;
+}
+
 static bool is_rename_target(
 	git_diff *diff,
 	const git_diff_find_options *opts,
@@ -810,7 +827,8 @@ int git_diff_find_similar(
 	git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
 	size_t num_deltas, num_srcs = 0, num_tgts = 0;
 	size_t tried_srcs = 0, tried_tgts = 0;
-	size_t num_rewrites = 0, num_updates = 0, num_bumped = 0;
+	size_t num_rewrites = 0, num_updates = 0, num_bumped = 0,
+	       num_to_delete = 0;
 	size_t sigcache_size;
 	void **sigcache = NULL; /* cache of similarity metric file signatures */
 	diff_find_match *tgt2src = NULL;
@@ -844,6 +862,8 @@ int git_diff_find_similar(
 	 * mark them for splitting if break-rewrites is enabled
 	 */
 	git_vector_foreach(&diff->deltas, t, tgt) {
+		handle_non_blob(diff, &opts, t);
+
 		if (is_rename_source(diff, &opts, t, sigcache))
 			++num_srcs;
 
@@ -852,11 +872,14 @@ int git_diff_find_similar(
 
 		if ((tgt->flags & GIT_DIFF_FLAG__TO_SPLIT) != 0)
 			num_rewrites++;
+
+		if ((tgt->flags & GIT_DIFF_FLAG__TO_DELETE) != 0)
+			num_to_delete++;
 	}
 
-	/* if there are no candidate srcs or tgts, we're done */
+	/* If there are no candidate srcs or tgts, no need to find matches */
 	if (!num_srcs || !num_tgts)
-		goto cleanup;
+		goto split_and_delete;
 
 	src2tgt = git__calloc(num_deltas, sizeof(diff_find_match));
 	GIT_ERROR_CHECK_ALLOC(src2tgt);
@@ -997,7 +1020,7 @@ find_best_matches:
 				memset(&src->new_file, 0, sizeof(src->new_file));
 				src->new_file.path = src->old_file.path;
 				src->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
-				git_oid_clear(&src->new_file.id, GIT_OID_SHA1);
+				git_oid_clear(&src->new_file.id, diff->opts.oid_type);
 
 				num_updates++;
 
@@ -1023,7 +1046,7 @@ find_best_matches:
 				memset(&src->old_file, 0, sizeof(src->old_file));
 				src->old_file.path = src->new_file.path;
 				src->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
-				git_oid_clear(&src->old_file.id, GIT_OID_SHA1);
+				git_oid_clear(&src->old_file.id, diff->opts.oid_type);
 
 				src->flags &= ~GIT_DIFF_FLAG__TO_SPLIT;
 				num_rewrites--;
@@ -1093,15 +1116,20 @@ find_best_matches:
 		}
 	}
 
+split_and_delete:
 	/*
 	 * Actually split and delete entries as needed
 	 */
 
-	if (num_rewrites > 0 || num_updates > 0)
+	if (num_rewrites > 0 || num_updates > 0 || num_to_delete > 0) {
+		size_t apply_len = diff->deltas.length -
+		                   num_rewrites - num_to_delete;
+
 		error = apply_splits_and_deletes(
-			diff, diff->deltas.length - num_rewrites,
+			diff, apply_len,
 			FLAG_SET(&opts, GIT_DIFF_BREAK_REWRITES) &&
 			!FLAG_SET(&opts, GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY));
+	}
 
 cleanup:
 	git__free(tgt2src);

data/vendor/libgit2/src/libgit2/diff_xdiff.h

@@ -10,7 +10,7 @@
 #include "common.h"
 
 #include "diff.h"
-#include "xdiff/xdiff.h"
+#include "xdiff.h"
 #include "patch_generate.h"
 
 /* xdiff cannot cope with large files.  these files should not be passed to

data/vendor/libgit2/src/libgit2/email.c

@@ -16,6 +16,7 @@
 
 #include "git2/email.h"
 #include "git2/patch.h"
+#include "git2/sys/email.h"
 #include "git2/version.h"
 
 /*
@@ -130,11 +131,12 @@ static int append_header(
 	const git_signature *author,
 	git_email_create_options *opts)
 {
-	char id[GIT_OID_SHA1_HEXSIZE];
+	char id[GIT_OID_MAX_HEXSIZE + 1];
 	int error;
 
-	if ((error = git_oid_fmt(id, commit_id)) < 0 ||
-	    (error = git_str_printf(out, "From %.*s %s\n", GIT_OID_SHA1_HEXSIZE, id, EMAIL_TIMESTAMP)) < 0 ||
+	git_oid_tostr(id, GIT_OID_MAX_HEXSIZE + 1, commit_id);
+
+	if ((error = git_str_printf(out, "From %s %s\n", id, EMAIL_TIMESTAMP)) < 0 ||
 	    (error = git_str_printf(out, "From: %s <%s>\n", author->name, author->email)) < 0 ||
 	    (error = append_date(out, &author->when)) < 0 ||
 	    (error = append_subject(out, patch_idx, patch_count, summary, opts)) < 0)