rugged 1.7.2 → 1.9.4

data/vendor/libgit2/src/libgit2/config_snapshot.c

@@ -8,12 +8,12 @@
 #include "config_backend.h"
 
 #include "config.h"
-#include "config_entries.h"
+#include "config_list.h"
 
 typedef struct {
 	git_config_backend parent;
 	git_mutex values_mutex;
-	git_config_entries *entries;
+	git_config_list *config_list;
 	git_config_backend *source;
 } config_snapshot_backend;
 
@@ -28,31 +28,27 @@ static int config_snapshot_iterator(
 	struct git_config_backend *backend)
 {
 	config_snapshot_backend *b = GIT_CONTAINER_OF(backend, config_snapshot_backend, parent);
-	git_config_entries *entries = NULL;
+	git_config_list *config_list = NULL;
 	int error;
 
-	if ((error = git_config_entries_dup(&entries, b->entries)) < 0 ||
-	    (error = git_config_entries_iterator_new(iter, entries)) < 0)
+	if ((error = git_config_list_dup(&config_list, b->config_list)) < 0 ||
+	    (error = git_config_list_iterator_new(iter, config_list)) < 0)
 		goto out;
 
 out:
-	/* Let iterator delete duplicated entries when it's done */
-	git_config_entries_free(entries);
+	/* Let iterator delete duplicated config_list when it's done */
+	git_config_list_free(config_list);
 	return error;
 }
 
-/* release the map containing the entry as an equivalent to freeing it */
-static void config_snapshot_entry_free(git_config_entry *entry)
-{
-	git_config_entries *entries = (git_config_entries *) entry->payload;
-	git_config_entries_free(entries);
-}
-
-static int config_snapshot_get(git_config_backend *cfg, const char *key, git_config_entry **out)
+static int config_snapshot_get(
+	git_config_backend *cfg,
+	const char *key,
+	git_config_backend_entry **out)
 {
 	config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent);
-	git_config_entries *entries = NULL;
-	git_config_entry *entry;
+	git_config_list *config_list = NULL;
+	git_config_list_entry *entry;
 	int error = 0;
 
 	if (git_mutex_lock(&b->values_mutex) < 0) {
@@ -60,19 +56,16 @@ static int config_snapshot_get(git_config_backend *cfg, const char *key, git_con
 	    return -1;
 	}
 
-	entries = b->entries;
-	git_config_entries_incref(entries);
+	config_list = b->config_list;
+	git_config_list_incref(config_list);
 	git_mutex_unlock(&b->values_mutex);
 
-	if ((error = (git_config_entries_get(&entry, entries, key))) < 0) {
-		git_config_entries_free(entries);
+	if ((error = (git_config_list_get(&entry, config_list, key))) < 0) {
+		git_config_list_free(config_list);
 		return error;
 	}
 
-	entry->free = config_snapshot_entry_free;
-	entry->payload = entries;
-	*out = entry;
-
+	*out = &entry->base;
 	return 0;
 }
 
@@ -135,7 +128,7 @@ static void config_snapshot_free(git_config_backend *_backend)
 	if (backend == NULL)
 		return;
 
-	git_config_entries_free(backend->entries);
+	git_config_list_free(backend->config_list);
 	git_mutex_free(&backend->values_mutex);
 	git__free(backend);
 }
@@ -143,7 +136,7 @@ static void config_snapshot_free(git_config_backend *_backend)
 static int config_snapshot_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
 {
 	config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent);
-	git_config_entries *entries = NULL;
+	git_config_list *config_list = NULL;
 	git_config_iterator *it = NULL;
 	git_config_entry *entry;
 	int error;
@@ -152,12 +145,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve
 	GIT_UNUSED(level);
 	GIT_UNUSED(repo);
 
-	if ((error = git_config_entries_new(&entries)) < 0 ||
+	if ((error = git_config_list_new(&config_list)) < 0 ||
 	    (error = b->source->iterator(&it, b->source)) < 0)
 		goto out;
 
 	while ((error = git_config_next(&entry, it)) == 0)
-		if ((error = git_config_entries_dup_entry(entries, entry)) < 0)
+		if ((error = git_config_list_dup_entry(config_list, entry)) < 0)
 			goto out;
 
 	if (error < 0) {
@@ -166,12 +159,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve
 		error = 0;
 	}
 
-	b->entries = entries;
+	b->config_list = config_list;
 
 out:
 	git_config_iterator_free(it);
 	if (error)
-		git_config_entries_free(entries);
+		git_config_list_free(config_list);
 	return error;
 }
 

data/vendor/libgit2/src/libgit2/delta.c

@@ -477,8 +477,12 @@ static int hdr_sz(
 			return -1;
 		}
 
+		if (shift >= (sizeof(size_t) * 8)) {
+			git_error_set(GIT_ERROR_INVALID, "delta header overflow");
+			return -1;
+		}
 		c = *d++;
-		r |= (c & 0x7f) << shift;
+		r |= ((size_t)(c & 0x7f)) << shift;
 		shift += 7;
 	} while (c & 0x80);
 	*delta = d;

data/vendor/libgit2/src/libgit2/describe.c

@@ -14,7 +14,6 @@
 #include "buf.h"
 #include "commit.h"
 #include "commit_list.h"
-#include "oidmap.h"
 #include "refs.h"
 #include "repository.h"
 #include "revwalk.h"
@@ -22,6 +21,7 @@
 #include "tag.h"
 #include "vector.h"
 #include "wildmatch.h"
+#include "hashmap_oid.h"
 
 /* Ported from https://github.com/git/git/blob/89dde7882f71f846ccd0359756d27bebc31108de/builtin/describe.c */
 
@@ -32,20 +32,22 @@ struct commit_name {
 	git_oid sha1;
 	char *path;
 
-	/* Khash workaround. They original key has to still be reachable */
+	/* The original key for the hashmap */
 	git_oid peeled;
 };
 
-static void *oidmap_value_bykey(git_oidmap *map, const git_oid *key)
-{
-	return git_oidmap_get(map, key);
-}
+GIT_HASHMAP_OID_SETUP(git_describe_oidmap, struct commit_name *);
 
 static struct commit_name *find_commit_name(
-	git_oidmap *names,
+	git_describe_oidmap *names,
 	const git_oid *peeled)
 {
-	return (struct commit_name *)(oidmap_value_bykey(names, peeled));
+	struct commit_name *result;
+
+	if (git_describe_oidmap_get(&result, names, peeled) == 0)
+		return result;
+
+	return NULL;
 }
 
 static int replace_name(
@@ -92,7 +94,7 @@ static int replace_name(
 
 static int add_to_known_names(
 	git_repository *repo,
-	git_oidmap *names,
+	git_describe_oidmap *names,
 	const char *path,
 	const git_oid *peeled,
 	unsigned int prio,
@@ -121,7 +123,7 @@ static int add_to_known_names(
 		e->path = git__strdup(path);
 		git_oid_cpy(&e->peeled, peeled);
 
-		if (!found && git_oidmap_set(names, &e->peeled, e) < 0)
+		if (!found && git_describe_oidmap_put(names, &e->peeled, e) < 0)
 			return -1;
 	}
 	else
@@ -174,7 +176,7 @@ struct get_name_data
 {
 	git_describe_options *opts;
 	git_repository *repo;
-	git_oidmap *names;
+	git_describe_oidmap names;
 	git_describe_result *result;
 };
 
@@ -240,7 +242,7 @@ static int get_name(const char *refname, void *payload)
 	else
 		prio = 0;
 
-	add_to_known_names(data->repo, data->names,
+	add_to_known_names(data->repo, &data->names,
 		all ? refname + strlen(GIT_REFS_DIR) : refname + strlen(GIT_REFS_TAGS_DIR),
 		&peeled, prio, &sha1);
 	return 0;
@@ -451,7 +453,7 @@ static int describe(
 
 	git_oid_cpy(&data->result->commit_id, git_commit_id(commit));
 
-	n = find_commit_name(data->names, git_commit_id(commit));
+	n = find_commit_name(&data->names, git_commit_id(commit));
 	if (n && (tags || all || n->prio == 2)) {
 		/*
 		 * Exact match to an existing ref.
@@ -492,7 +494,7 @@ static int describe(
 		git_commit_list_node *c = (git_commit_list_node *)git_pqueue_pop(&list);
 		seen_commits++;
 
-		n = find_commit_name(data->names, &c->oid);
+		n = find_commit_name(&data->names, &c->oid);
 
 		if (n) {
 			if (!tags && !all && n->prio < 2) {
@@ -627,7 +629,7 @@ cleanup:
 			git__free(match);
 		}
 	}
-	git_vector_free(&all_matches);
+	git_vector_dispose(&all_matches);
 	git_pqueue_free(&list);
 	git_revwalk_free(walk);
 	return error;
@@ -653,11 +655,12 @@ int git_describe_commit(
 	git_object *committish,
 	git_describe_options *opts)
 {
-	struct get_name_data data;
+	struct get_name_data data = {0};
 	struct commit_name *name;
 	git_commit *commit;
-	int error = -1;
 	git_describe_options normalized;
+	git_hashmap_iter_t iter = GIT_HASHMAP_INIT;
+	int error = -1;
 
 	GIT_ASSERT_ARG(result);
 	GIT_ASSERT_ARG(committish);
@@ -677,9 +680,6 @@ int git_describe_commit(
 		"git_describe_options");
 	data.opts = &normalized;
 
-	if ((error = git_oidmap_new(&data.names)) < 0)
-		return error;
-
 	/** TODO: contains to be implemented */
 
 	if ((error = git_object_peel((git_object **)(&commit), committish, GIT_OBJECT_COMMIT)) < 0)
@@ -690,7 +690,7 @@ int git_describe_commit(
 			get_name, &data)) < 0)
 				goto cleanup;
 
-	if (git_oidmap_size(data.names) == 0 && !normalized.show_commit_oid_as_fallback) {
+	if (git_describe_oidmap_size(&data.names) == 0 && !normalized.show_commit_oid_as_fallback) {
 		git_error_set(GIT_ERROR_DESCRIBE, "cannot describe - "
 			"no reference found, cannot describe anything.");
 		error = -1;
@@ -703,13 +703,13 @@ int git_describe_commit(
 cleanup:
 	git_commit_free(commit);
 
-	git_oidmap_foreach_value(data.names, name, {
+	while (git_describe_oidmap_iterate(&iter, NULL, &name, &data.names) == 0) {
 		git_tag_free(name->tag);
 		git__free(name->path);
 		git__free(name);
-	});
+	}
 
-	git_oidmap_free(data.names);
+	git_describe_oidmap_dispose(&data.names);
 
 	if (error < 0)
 		git_describe_result_free(data.result);

data/vendor/libgit2/src/libgit2/diff.c

@@ -16,7 +16,7 @@
 #include "diff_generate.h"
 
 #include "git2/version.h"
-#include "git2/email.h"
+#include "git2/sys/email.h"
 
 struct patch_id_args {
 	git_diff *diff;

data/vendor/libgit2/src/libgit2/diff_driver.c

@@ -11,11 +11,11 @@
 
 #include "common.h"
 #include "diff.h"
-#include "strmap.h"
 #include "map.h"
 #include "config.h"
 #include "regexp.h"
 #include "repository.h"
+#include "userdiff.h"
 
 typedef enum {
 	DIFF_DRIVER_AUTO = 0,
@@ -43,10 +43,10 @@ struct git_diff_driver {
 	char name[GIT_FLEX_ARRAY];
 };
 
-#include "userdiff.h"
+GIT_HASHMAP_STR_SETUP(git_diff_driver_map, git_diff_driver *);
 
 struct git_diff_driver_registry {
-	git_strmap *drivers;
+	git_diff_driver_map map;
 };
 
 #define FORCE_DIFFABLE (GIT_DIFF_FORCE_TEXT | GIT_DIFF_FORCE_BINARY)
@@ -57,28 +57,21 @@ static git_diff_driver diff_driver_text =   { DIFF_DRIVER_TEXT,   GIT_DIFF_FORCE
 
 git_diff_driver_registry *git_diff_driver_registry_new(void)
 {
-	git_diff_driver_registry *reg =
-		git__calloc(1, sizeof(git_diff_driver_registry));
-	if (!reg)
-		return NULL;
-
-	if (git_strmap_new(&reg->drivers) < 0) {
-		git_diff_driver_registry_free(reg);
-		return NULL;
-	}
-
-	return reg;
+	return git__calloc(1, sizeof(git_diff_driver_registry));
 }
 
 void git_diff_driver_registry_free(git_diff_driver_registry *reg)
 {
 	git_diff_driver *drv;
+	git_hashmap_iter_t iter = 0;
 
 	if (!reg)
 		return;
 
-	git_strmap_foreach_value(reg->drivers, drv, git_diff_driver_free(drv));
-	git_strmap_free(reg->drivers);
+	while (git_diff_driver_map_iterate(&iter, NULL, &drv, &reg->map) == 0)
+		git_diff_driver_free(drv);
+
+	git_diff_driver_map_dispose(&reg->map);
 	git__free(reg);
 }
 
@@ -215,7 +208,7 @@ static int git_diff_driver_builtin(
 	    (error = git_regexp_compile(&drv->word_pattern, ddef->words, ddef->flags)) < 0)
 		goto done;
 
-	if ((error = git_strmap_set(reg->drivers, drv->name, drv)) < 0)
+	if ((error = git_diff_driver_map_put(&reg->map, drv->name, drv)) < 0)
 		goto done;
 
 done:
@@ -232,7 +225,7 @@ static int git_diff_driver_load(
 {
 	int error = 0;
 	git_diff_driver_registry *reg;
-	git_diff_driver *drv;
+	git_diff_driver *drv = NULL;
 	size_t namelen;
 	git_config *cfg = NULL;
 	git_str name = GIT_STR_INIT;
@@ -242,7 +235,7 @@ static int git_diff_driver_load(
 	if ((reg = git_repository_driver_registry(repo)) == NULL)
 		return -1;
 
-	if ((drv = git_strmap_get(reg->drivers, driver_name)) != NULL) {
+	if (git_diff_driver_map_get(&drv, &reg->map, driver_name) == 0) {
 		*out = drv;
 		return 0;
 	}
@@ -331,7 +324,7 @@ static int git_diff_driver_load(
 		goto done;
 
 	/* store driver in registry */
-	if ((error = git_strmap_set(reg->drivers, drv->name, drv)) < 0)
+	if ((error = git_diff_driver_map_put(&reg->map, drv->name, drv)) < 0)
 		goto done;
 
 	*out = drv;

data/vendor/libgit2/src/libgit2/diff_driver.h

@@ -11,14 +11,14 @@
 
 #include "attr_file.h"
 #include "str.h"
+#include "hashmap.h"
 
+typedef struct git_diff_driver git_diff_driver;
 typedef struct git_diff_driver_registry git_diff_driver_registry;
 
 git_diff_driver_registry *git_diff_driver_registry_new(void);
 void git_diff_driver_registry_free(git_diff_driver_registry *);
 
-typedef struct git_diff_driver git_diff_driver;
-
 int git_diff_driver_lookup(git_diff_driver **, git_repository *,
 	git_attr_session *attrsession, const char *);
 void git_diff_driver_free(git_diff_driver *);

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

@@ -429,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);
@@ -729,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;
 
@@ -745,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;
 

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

@@ -20,9 +20,9 @@ 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));

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,7 @@ 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 *);
@@ -52,14 +54,10 @@ static int diff_print_info_init__common(
 	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 > 0 &&
-	    (size_t)pi->id_strlen > git_oid_hexsize(pi->oid_type))
-		pi->id_strlen = (int)git_oid_hexsize(pi->oid_type);
-
 	memset(&pi->line, 0, sizeof(pi->line));
 	pi->line.old_lineno = -1;
 	pi->line.new_lineno = -1;
@@ -579,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)
 {
@@ -609,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(
@@ -632,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(
@@ -651,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;
@@ -669,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);
 }
 
@@ -705,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_stats.c

@@ -28,7 +28,6 @@ struct git_diff_stats {
 	size_t files_changed;
 	size_t insertions;
 	size_t deletions;
-	size_t renames;
 
 	size_t max_name;
 	size_t max_filestat;
@@ -68,17 +67,19 @@ static int diff_file_stats_full_to_buf(
 		size_t common_dirlen;
 		int error;
 
-		padding = stats->max_name - strlen(old_path) - strlen(new_path);
-
 		if ((common_dirlen = git_fs_path_common_dirlen(old_path, new_path)) &&
 		    common_dirlen <= INT_MAX) {
 			error = git_str_printf(out, " %.*s{%s"DIFF_RENAME_FILE_SEPARATOR"%s}",
 					       (int) common_dirlen, old_path,
 					       old_path + common_dirlen,
 					       new_path + common_dirlen);
+			padding = stats->max_name + common_dirlen - strlen(old_path)
+			          - strlen(new_path) - 2 - strlen(DIFF_RENAME_FILE_SEPARATOR);
 		} else {
 			error = git_str_printf(out, " %s" DIFF_RENAME_FILE_SEPARATOR "%s",
 					       old_path, new_path);
+			padding = stats->max_name - strlen(old_path)
+			          - strlen(new_path) - strlen(DIFF_RENAME_FILE_SEPARATOR);
 		}
 
 		if (error < 0)
@@ -89,9 +90,6 @@ static int diff_file_stats_full_to_buf(
 			goto on_error;
 
 		padding = stats->max_name - strlen(adddel_path);
-
-		if (stats->renames > 0)
-			padding += strlen(DIFF_RENAME_FILE_SEPARATOR);
 	}
 
 	if (git_str_putcn(out, ' ', padding) < 0 ||
@@ -210,14 +208,23 @@ int git_diff_get_stats(
 		if ((error = git_patch_from_diff(&patch, diff, i)) < 0)
 			break;
 
-		/* keep a count of renames because it will affect formatting */
+		/* Length calculation for renames mirrors the actual presentation format
+		 * generated in diff_file_stats_full_to_buf; namelen is the full length of
+		 * what will be printed, taking into account renames and common prefixes.
+		 */
 		delta = patch->delta;
-
-		/* TODO ugh */
 		namelen = strlen(delta->new_file.path);
-		if (delta->old_file.path && strcmp(delta->old_file.path, delta->new_file.path) != 0) {
-			namelen += strlen(delta->old_file.path);
-			stats->renames++;
+		if (delta->old_file.path &&
+		    strcmp(delta->old_file.path, delta->new_file.path) != 0) {
+			size_t common_dirlen;
+			if ((common_dirlen = git_fs_path_common_dirlen(delta->old_file.path, delta->new_file.path)) &&
+			    common_dirlen <= INT_MAX) {
+				namelen += strlen(delta->old_file.path) + 2 +
+				           strlen(DIFF_RENAME_FILE_SEPARATOR) - common_dirlen;
+			} else {
+				namelen += strlen(delta->old_file.path) +
+				           strlen(DIFF_RENAME_FILE_SEPARATOR);
+			}
 		}
 
 		/* and, of course, count the line stats */