rugged 1.3.2 → 1.6.2

data/vendor/libgit2/src/{diff_driver.c → libgit2/diff_driver.c}

@@ -21,7 +21,7 @@ typedef enum {
 	DIFF_DRIVER_AUTO = 0,
 	DIFF_DRIVER_BINARY = 1,
 	DIFF_DRIVER_TEXT = 2,
-	DIFF_DRIVER_PATTERNLIST = 3,
+	DIFF_DRIVER_PATTERNLIST = 3
 } git_diff_driver_t;
 
 typedef struct {
@@ -51,11 +51,9 @@ struct git_diff_driver_registry {
 
 #define FORCE_DIFFABLE (GIT_DIFF_FORCE_TEXT | GIT_DIFF_FORCE_BINARY)
 
-static git_diff_driver global_drivers[3] = {
-	{ DIFF_DRIVER_AUTO,   0, 0, },
-	{ DIFF_DRIVER_BINARY, GIT_DIFF_FORCE_BINARY, 0 },
-	{ DIFF_DRIVER_TEXT,   GIT_DIFF_FORCE_TEXT, 0 },
-};
+static git_diff_driver diff_driver_auto =   { DIFF_DRIVER_AUTO,   0, 0 };
+static git_diff_driver diff_driver_binary = { DIFF_DRIVER_BINARY, GIT_DIFF_FORCE_BINARY, 0 };
+static git_diff_driver diff_driver_text =   { DIFF_DRIVER_TEXT,   GIT_DIFF_FORCE_TEXT, 0 };
 
 git_diff_driver_registry *git_diff_driver_registry_new(void)
 {
@@ -90,7 +88,7 @@ static int diff_driver_add_patterns(
 	int error = 0;
 	const char *scan, *end;
 	git_diff_driver_pattern *pat = NULL;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 
 	for (scan = regex_str; scan; scan = end) {
 		/* get pattern to fill in */
@@ -105,10 +103,10 @@ static int diff_driver_add_patterns(
 		}
 
 		if ((end = strchr(scan, '\n')) != NULL) {
-			error = git_buf_set(&buf, scan, end - scan);
+			error = git_str_set(&buf, scan, end - scan);
 			end++;
 		} else {
-			error = git_buf_sets(&buf, scan);
+			error = git_str_sets(&buf, scan);
 		}
 		if (error < 0)
 			break;
@@ -122,7 +120,7 @@ static int diff_driver_add_patterns(
 
 	if (error && pat != NULL)
 		(void)git_array_pop(drv->fn_patterns); /* release last item */
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 
 	/* We want to ignore bad patterns, so return success regardless */
 	return 0;
@@ -237,7 +235,7 @@ static int git_diff_driver_load(
 	git_diff_driver *drv;
 	size_t namelen;
 	git_config *cfg = NULL;
-	git_buf name = GIT_BUF_INIT;
+	git_str name = GIT_STR_INIT;
 	git_config_entry *ce = NULL;
 	bool found_driver = false;
 
@@ -260,13 +258,13 @@ static int git_diff_driver_load(
 		goto done;
 	}
 
-	if ((error = git_buf_printf(&name, "diff.%s.binary", driver_name)) < 0)
+	if ((error = git_str_printf(&name, "diff.%s.binary", driver_name)) < 0)
 		goto done;
 
 	switch (git_config__get_bool_force(cfg, name.ptr, -1)) {
 	case true:
 		/* if diff.<driver>.binary is true, just return the binary driver */
-		*out = &global_drivers[DIFF_DRIVER_BINARY];
+		*out = &diff_driver_binary;
 		goto done;
 	case false:
 		/* if diff.<driver>.binary is false, force binary checks off */
@@ -281,8 +279,8 @@ static int git_diff_driver_load(
 
 	/* TODO: warn if diff.<name>.command or diff.<name>.textconv are set */
 
-	git_buf_truncate(&name, namelen + strlen("diff.."));
-	if ((error = git_buf_PUTS(&name, "xfuncname")) < 0)
+	git_str_truncate(&name, namelen + strlen("diff.."));
+	if ((error = git_str_PUTS(&name, "xfuncname")) < 0)
 		goto done;
 
 	if ((error = git_config_get_multivar_foreach(
@@ -292,8 +290,8 @@ static int git_diff_driver_load(
 		git_error_clear(); /* no diff.<driver>.xfuncname, so just continue */
 	}
 
-	git_buf_truncate(&name, namelen + strlen("diff.."));
-	if ((error = git_buf_PUTS(&name, "funcname")) < 0)
+	git_str_truncate(&name, namelen + strlen("diff.."));
+	if ((error = git_str_PUTS(&name, "funcname")) < 0)
 		goto done;
 
 	if ((error = git_config_get_multivar_foreach(
@@ -309,8 +307,8 @@ static int git_diff_driver_load(
 		found_driver = true;
 	}
 
-	git_buf_truncate(&name, namelen + strlen("diff.."));
-	if ((error = git_buf_PUTS(&name, "wordregex")) < 0)
+	git_str_truncate(&name, namelen + strlen("diff.."));
+	if ((error = git_str_PUTS(&name, "wordregex")) < 0)
 		goto done;
 
 	if ((error = git_config__lookup_entry(&ce, cfg, name.ptr, false)) < 0)
@@ -340,7 +338,7 @@ static int git_diff_driver_load(
 
 done:
 	git_config_entry_free(ce);
-	git_buf_dispose(&name);
+	git_str_dispose(&name);
 	git_config_free(cfg);
 
 	if (!*out) {
@@ -374,9 +372,9 @@ int git_diff_driver_lookup(
 	else if (GIT_ATTR_IS_UNSPECIFIED(values[0]))
 		/* just use the auto value */;
 	else if (GIT_ATTR_IS_FALSE(values[0]))
-		*out = &global_drivers[DIFF_DRIVER_BINARY];
+		*out = &diff_driver_binary;
 	else if (GIT_ATTR_IS_TRUE(values[0]))
-		*out = &global_drivers[DIFF_DRIVER_TEXT];
+		*out = &diff_driver_text;
 
 	/* otherwise look for driver information in config and build driver */
 	else if ((error = git_diff_driver_load(out, repo, values[0])) < 0) {
@@ -387,7 +385,7 @@ int git_diff_driver_lookup(
 	}
 
 	if (!*out)
-		*out = &global_drivers[DIFF_DRIVER_AUTO];
+		*out = &diff_driver_auto;
 
 	return error;
 }
@@ -420,11 +418,11 @@ void git_diff_driver_update_options(
 int git_diff_driver_content_is_binary(
 	git_diff_driver *driver, const char *content, size_t content_len)
 {
-	git_buf search = GIT_BUF_INIT;
+	git_str search = GIT_STR_INIT;
 
 	GIT_UNUSED(driver);
 
-	git_buf_attach_notowned(&search, content,
+	git_str_attach_notowned(&search, content,
 		min(content_len, GIT_FILTER_BYTES_TO_CHECK_NUL));
 
 	/* TODO: provide encoding / binary detection callbacks that can
@@ -432,15 +430,15 @@ int git_diff_driver_content_is_binary(
 	 * let's just use the simple NUL-byte detection that core git uses.
 	 */
 
-	/* previously was: if (git_buf_is_binary(&search)) */
-	if (git_buf_contains_nul(&search))
+	/* previously was: if (git_str_is_binary(&search)) */
+	if (git_str_contains_nul(&search))
 		return 1;
 
 	return 0;
 }
 
 static int diff_context_line__simple(
-	git_diff_driver *driver, git_buf *line)
+	git_diff_driver *driver, git_str *line)
 {
 	char firstch = line->ptr[0];
 	GIT_UNUSED(driver);
@@ -448,7 +446,7 @@ static int diff_context_line__simple(
 }
 
 static int diff_context_line__pattern_match(
-	git_diff_driver *driver, git_buf *line)
+	git_diff_driver *driver, git_str *line)
 {
 	size_t i, maxi = git_array_size(driver->fn_patterns);
 	git_regmatch pmatch[2];
@@ -462,9 +460,9 @@ static int diff_context_line__pattern_match(
 
 			/* use pmatch data to trim line data */
 			i = (pmatch[1].start >= 0) ? 1 : 0;
-			git_buf_consume(line, git_buf_cstr(line) + pmatch[i].start);
-			git_buf_truncate(line, pmatch[i].end - pmatch[i].start);
-			git_buf_rtrim(line);
+			git_str_consume(line, git_str_cstr(line) + pmatch[i].start);
+			git_str_truncate(line, pmatch[i].end - pmatch[i].start);
+			git_str_rtrim(line);
 
 			return true;
 		}
@@ -482,9 +480,9 @@ static long diff_context_find(
 {
 	git_diff_find_context_payload *ctxt = payload;
 
-	if (git_buf_set(&ctxt->line, line, (size_t)line_len) < 0)
+	if (git_str_set(&ctxt->line, line, (size_t)line_len) < 0)
 		return -1;
-	git_buf_rtrim(&ctxt->line);
+	git_str_rtrim(&ctxt->line);
 
 	if (!ctxt->line.size)
 		return -1;
@@ -511,14 +509,14 @@ void git_diff_find_context_init(
 		payload_out->driver = driver;
 		payload_out->match_line = (driver->type == DIFF_DRIVER_PATTERNLIST) ?
 			diff_context_line__pattern_match : diff_context_line__simple;
-		git_buf_init(&payload_out->line, 0);
+		git_str_init(&payload_out->line, 0);
 	}
 }
 
 void git_diff_find_context_clear(git_diff_find_context_payload *payload)
 {
 	if (payload) {
-		git_buf_dispose(&payload->line);
+		git_str_dispose(&payload->line);
 		payload->driver = NULL;
 	}
 }

data/vendor/libgit2/src/{diff_driver.h → libgit2/diff_driver.h}

@@ -10,7 +10,7 @@
 #include "common.h"
 
 #include "attr_file.h"
-#include "buffer.h"
+#include "str.h"
 
 typedef struct git_diff_driver_registry git_diff_driver_registry;
 
@@ -34,12 +34,12 @@ typedef long (*git_diff_find_context_fn)(
 	const char *, long, char *, long, void *);
 
 typedef int (*git_diff_find_context_line)(
-	git_diff_driver *, git_buf *);
+	git_diff_driver *, git_str *);
 
 typedef struct {
 	git_diff_driver *driver;
 	git_diff_find_context_line match_line;
-	git_buf line;
+	git_str line;
 } git_diff_find_context_payload;
 
 void git_diff_find_context_init(

data/vendor/libgit2/src/{diff_file.c → libgit2/diff_file.c}

@@ -144,6 +144,7 @@ int git_diff_file_content__init_from_src(
 
 	if (!src->blob && !src->buf) {
 		fc->flags |= GIT_DIFF_FLAG__NO_DATA;
+		git_oid_clear(&fc->file->id, GIT_OID_SHA1);
 	} else {
 		fc->flags |= GIT_DIFF_FLAG__LOADED;
 		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
@@ -153,7 +154,7 @@ int git_diff_file_content__init_from_src(
 			git_blob_dup((git_blob **)&fc->blob, (git_blob *) src->blob);
 			fc->file->size = git_blob_rawsize(src->blob);
 			git_oid_cpy(&fc->file->id, git_blob_id(src->blob));
-			fc->file->id_abbrev = GIT_OID_HEXSZ;
+			fc->file->id_abbrev = GIT_OID_SHA1_HEXSIZE;
 
 			fc->map.len  = (size_t)fc->file->size;
 			fc->map.data = (char *)git_blob_rawcontent(src->blob);
@@ -161,10 +162,10 @@ int git_diff_file_content__init_from_src(
 			fc->flags |= GIT_DIFF_FLAG__FREE_BLOB;
 		} else {
 			int error;
-			if ((error = git_odb_hash(&fc->file->id, src->buf, src->buflen, GIT_OBJECT_BLOB)) < 0)
+			if ((error = git_odb__hash(&fc->file->id, src->buf, src->buflen, GIT_OBJECT_BLOB, GIT_OID_SHA1)) < 0)
 				return error;
 			fc->file->size = src->buflen;
-			fc->file->id_abbrev = GIT_OID_HEXSZ;
+			fc->file->id_abbrev = GIT_OID_SHA1_HEXSIZE;
 
 			fc->map.len  = src->buflen;
 			fc->map.data = (char *)src->buf;
@@ -177,8 +178,8 @@ int git_diff_file_content__init_from_src(
 static int diff_file_content_commit_to_str(
 	git_diff_file_content *fc, bool check_status)
 {
-	char oid[GIT_OID_HEXSZ+1];
-	git_buf content = GIT_BUF_INIT;
+	char oid[GIT_OID_SHA1_HEXSIZE+1];
+	git_str content = GIT_STR_INIT;
 	const char *status = "";
 
 	if (check_status) {
@@ -217,11 +218,11 @@ static int diff_file_content_commit_to_str(
 	}
 
 	git_oid_tostr(oid, sizeof(oid), &fc->file->id);
-	if (git_buf_printf(&content, "Subproject commit %s%s\n", oid, status) < 0)
+	if (git_str_printf(&content, "Subproject commit %s%s\n", oid, status) < 0)
 		return -1;
 
-	fc->map.len  = git_buf_len(&content);
-	fc->map.data = git_buf_detach(&content);
+	fc->map.len  = git_str_len(&content);
+	fc->map.data = git_str_detach(&content);
 	fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 
 	return 0;
@@ -270,24 +271,24 @@ static int diff_file_content_load_blob(
 }
 
 static int diff_file_content_load_workdir_symlink_fake(
-	git_diff_file_content *fc, git_buf *path)
+	git_diff_file_content *fc, git_str *path)
 {
-	git_buf target = GIT_BUF_INIT;
+	git_str target = GIT_STR_INIT;
 	int error;
 
 	if ((error = git_futils_readbuffer(&target, path->ptr)) < 0)
 		return error;
 
-	fc->map.len = git_buf_len(&target);
-	fc->map.data = git_buf_detach(&target);
+	fc->map.len = git_str_len(&target);
+	fc->map.data = git_str_detach(&target);
 	fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 
-	git_buf_dispose(&target);
+	git_str_dispose(&target);
 	return error;
 }
 
 static int diff_file_content_load_workdir_symlink(
-	git_diff_file_content *fc, git_buf *path)
+	git_diff_file_content *fc, git_str *path)
 {
 	ssize_t alloc_len, read_len;
 	int symlink_supported, error;
@@ -309,7 +310,7 @@ static int diff_file_content_load_workdir_symlink(
 
 	fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 
-	read_len = p_readlink(git_buf_cstr(path), fc->map.data, alloc_len);
+	read_len = p_readlink(git_str_cstr(path), fc->map.data, alloc_len);
 	if (read_len < 0) {
 		git_error_set(GIT_ERROR_OS, "failed to read symlink '%s'", fc->file->path);
 		return -1;
@@ -321,23 +322,39 @@ static int diff_file_content_load_workdir_symlink(
 
 static int diff_file_content_load_workdir_file(
 	git_diff_file_content *fc,
-	git_buf *path,
+	git_str *path,
 	git_diff_options *diff_opts)
 {
 	int error = 0;
 	git_filter_list *fl = NULL;
-	git_file fd = git_futils_open_ro(git_buf_cstr(path));
-	git_buf raw = GIT_BUF_INIT;
+	git_file fd = git_futils_open_ro(git_str_cstr(path));
+	git_str raw = GIT_STR_INIT;
+	git_object_size_t new_file_size = 0;
 
 	if (fd < 0)
 		return fd;
 
-	if (!fc->file->size)
-	    error = git_futils_filesize(&fc->file->size, fd);
+	error = git_futils_filesize(&new_file_size, fd);
 
-	if (error < 0 || !fc->file->size)
+	if (error < 0)
 		goto cleanup;
 
+	if (!(fc->file->flags & GIT_DIFF_FLAG_VALID_SIZE)) {
+		fc->file->size = new_file_size;
+		fc->file->flags |= GIT_DIFF_FLAG_VALID_SIZE;
+	} else if (fc->file->size != new_file_size) {
+		git_error_set(GIT_ERROR_FILESYSTEM, "file changed before we could read it");
+		error = -1;
+		goto cleanup;
+	}
+
+	/* if file is empty, don't attempt to mmap or readbuffer */
+	if (fc->file->size == 0) {
+		fc->map.len = 0;
+		fc->map.data = git_str__initstr;
+		goto cleanup;
+	}
+
 	if ((diff_opts->flags & GIT_DIFF_SHOW_BINARY) == 0 &&
 		diff_file_content_binary_by_size(fc))
 		goto cleanup;
@@ -360,7 +377,7 @@ static int diff_file_content_load_workdir_file(
 	}
 
 	if (!(error = git_futils_readbuffer_fd(&raw, fd, (size_t)fc->file->size))) {
-		git_buf out = GIT_BUF_INIT;
+		git_str out = GIT_STR_INIT;
 
 		error = git_filter_list__convert_buf(&out, fl, &raw);
 
@@ -383,7 +400,7 @@ static int diff_file_content_load_workdir(
 	git_diff_options *diff_opts)
 {
 	int error = 0;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 
 	if (fc->file->mode == GIT_FILEMODE_COMMIT)
 		return diff_file_content_commit_to_str(fc, true);
@@ -401,12 +418,13 @@ static int diff_file_content_load_workdir(
 
 	/* once data is loaded, update OID if we didn't have it previously */
 	if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0) {
-		error = git_odb_hash(
-			&fc->file->id, fc->map.data, fc->map.len, GIT_OBJECT_BLOB);
+		error = git_odb__hash(
+			&fc->file->id, fc->map.data, fc->map.len,
+			GIT_OBJECT_BLOB, GIT_OID_SHA1);
 		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 	}
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	return error;
 }
 

data/vendor/libgit2/src/{diff_generate.c → libgit2/diff_generate.c}

@@ -61,6 +61,9 @@ 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);
+
 	return delta;
 }
 
@@ -117,6 +120,26 @@ static bool diff_pathspec_match(
 		matched_pathspec, NULL);
 }
 
+static void diff_delta__flag_known_size(git_diff_file *file)
+{
+	/*
+	 * If we don't know the ID, that can only come from the workdir
+	 * iterator, which means we *do* know the file size.  This is a
+	 * leaky abstraction, but alas.  Otherwise, we test against the
+	 * empty blob id.
+	 */
+	if (file->size ||
+	    !(file->flags & GIT_DIFF_FLAG_VALID_ID) ||
+	    git_oid_equal(&file->id, &git_oid__empty_blob_sha1))
+		file->flags |= GIT_DIFF_FLAG_VALID_SIZE;
+}
+
+static void diff_delta__flag_known_sizes(git_diff_delta *delta)
+{
+	diff_delta__flag_known_size(&delta->old_file);
+	diff_delta__flag_known_size(&delta->new_file);
+}
+
 static int diff_delta__from_one(
 	git_diff_generated *diff,
 	git_delta_t status,
@@ -168,13 +191,15 @@ static int diff_delta__from_one(
 		delta->old_file.size = entry->file_size;
 		delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS;
 		git_oid_cpy(&delta->old_file.id, &entry->id);
-		delta->old_file.id_abbrev = GIT_OID_HEXSZ;
+		git_oid_clear(&delta->new_file.id, GIT_OID_SHA1);
+		delta->old_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
 	} 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_cpy(&delta->new_file.id, &entry->id);
-		delta->new_file.id_abbrev = GIT_OID_HEXSZ;
+		delta->new_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
 	}
 
 	delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
@@ -182,6 +207,8 @@ static int diff_delta__from_one(
 	if (has_old || !git_oid_is_zero(&delta->new_file.id))
 		delta->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
+	diff_delta__flag_known_sizes(delta);
+
 	return diff_insert_delta(diff, delta, matched_pathspec);
 }
 
@@ -227,14 +254,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_HEXSZ;
+		delta->old_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
 		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_HEXSZ;
+		delta->new_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
 		delta->new_file.size = new_entry->file_size;
 		delta->new_file.mode = new_mode;
 		delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS;
@@ -244,6 +271,8 @@ static int diff_delta__from_two(
 			delta->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 	}
 
+	diff_delta__flag_known_sizes(delta);
+
 	return diff_insert_delta(diff, delta, matched_pathspec);
 }
 
@@ -574,6 +603,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);
 
 	return git_diff__oid_for_entry(out, diff, &entry, mode, NULL);
 }
@@ -586,7 +616,7 @@ int git_diff__oid_for_entry(
 	const git_oid *update_match)
 {
 	git_diff_generated *diff;
-	git_buf full_path = GIT_BUF_INIT;
+	git_str full_path = GIT_STR_INIT;
 	git_index_entry entry = *src;
 	git_filter_list *fl = NULL;
 	int error = 0;
@@ -594,7 +624,7 @@ int git_diff__oid_for_entry(
 	GIT_ASSERT(d->type == GIT_DIFF_TYPE_GENERATED);
 	diff = (git_diff_generated *)d;
 
-	memset(out, 0, sizeof(*out));
+	git_oid_clear(out, GIT_OID_SHA1);
 
 	if (git_repository_workdir_path(&full_path, diff->base.repo, entry.path) < 0)
 		return -1;
@@ -605,8 +635,8 @@ int git_diff__oid_for_entry(
 		diff->base.perf.stat_calls++;
 
 		if (p_stat(full_path.ptr, &st) < 0) {
-			error = git_path_set_error(errno, entry.path, "stat");
-			git_buf_dispose(&full_path);
+			error = git_fs_path_set_error(errno, entry.path, "stat");
+			git_str_dispose(&full_path);
 			return error;
 		}
 
@@ -630,7 +660,7 @@ int git_diff__oid_for_entry(
 			git_error_clear();
 		}
 	} else if (S_ISLNK(mode)) {
-		error = git_odb__hashlink(out, full_path.ptr);
+		error = git_odb__hashlink(out, full_path.ptr, GIT_OID_SHA1);
 		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'",
@@ -645,7 +675,8 @@ int git_diff__oid_for_entry(
 			error = fd;
 		else {
 			error = git_odb__hashfd_filtered(
-				out, fd, (size_t)entry.file_size, GIT_OBJECT_BLOB, fl);
+				out, fd, (size_t)entry.file_size,
+				GIT_OBJECT_BLOB, GIT_OID_SHA1, fl);
 			p_close(fd);
 			diff->base.perf.oid_calculations++;
 		}
@@ -669,7 +700,7 @@ int git_diff__oid_for_entry(
 		}
  	}
 
-	git_buf_dispose(&full_path);
+	git_str_dispose(&full_path);
 	return error;
 }
 
@@ -754,7 +785,7 @@ static int maybe_modified(
 	git_diff_generated *diff,
 	diff_in_progress *info)
 {
-	git_oid noid;
+	git_oid noid = GIT_OID_SHA1_ZERO;
 	git_delta_t status = GIT_DELTA_MODIFIED;
 	const git_index_entry *oitem = info->oitem;
 	const git_index_entry *nitem = info->nitem;
@@ -768,8 +799,6 @@ static int maybe_modified(
 	if (!diff_pathspec_match(&matched_pathspec, diff, oitem))
 		return 0;
 
-	memset(&noid, 0, sizeof(noid));
-
 	/* on platforms with no symlinks, preserve mode of existing symlinks */
 	if (S_ISLNK(omode) && S_ISREG(nmode) && new_is_workdir &&
 		!(diff->diffcaps & GIT_DIFFCAPS_HAS_SYMLINKS))
@@ -1023,10 +1052,10 @@ static int handle_unmatched_new_item(
 
 		/* do not advance into directories that contain a .git file */
 		if (recurse_into_dir && !contains_oitem) {
-			git_buf *full = NULL;
+			git_str *full = NULL;
 			if (git_iterator_current_workdir_path(&full, info->new_iter) < 0)
 				return -1;
-			if (full && git_path_contains(full, DOT_GIT)) {
+			if (full && git_fs_path_contains(full, DOT_GIT)) {
 				/* TODO: warning if not a valid git repository */
 				recurse_into_dir = false;
 			}
@@ -1671,11 +1700,11 @@ int git_diff__commit(
 	*out = NULL;
 
 	if ((parents = git_commit_parentcount(commit)) > 1) {
-		char commit_oidstr[GIT_OID_HEXSZ + 1];
+		char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
 
 		error = -1;
 		git_error_set(GIT_ERROR_INVALID, "commit %s is a merge commit",
-			git_oid_tostr(commit_oidstr, GIT_OID_HEXSZ + 1, git_commit_id(commit)));
+			git_oid_tostr(commit_oidstr, GIT_OID_SHA1_HEXSIZE + 1, git_commit_id(commit)));
 		goto on_error;
 	}
 

data/vendor/libgit2/src/{diff_generate.h → libgit2/diff_generate.h}

@@ -18,7 +18,7 @@ enum {
 	GIT_DIFFCAPS_IGNORE_STAT      = (1 << 1), /* use stat? */
 	GIT_DIFFCAPS_TRUST_MODE_BITS  = (1 << 2), /* use st_mode? */
 	GIT_DIFFCAPS_TRUST_CTIME      = (1 << 3), /* use st_ctime? */
-	GIT_DIFFCAPS_USE_DEV          = (1 << 4), /* use st_dev? */
+	GIT_DIFFCAPS_USE_DEV          = (1 << 4)  /* use st_dev? */
 };
 
 #define DIFF_FLAGS_KNOWN_BINARY (GIT_DIFF_FLAG_BINARY|GIT_DIFF_FLAG_NOT_BINARY)
@@ -36,7 +36,7 @@ enum {
 	GIT_DIFF_FLAG__TO_SPLIT   = (1 << 17), /* split entry during rename det. */
 	GIT_DIFF_FLAG__IS_RENAME_TARGET = (1 << 18),
 	GIT_DIFF_FLAG__IS_RENAME_SOURCE = (1 << 19),
-	GIT_DIFF_FLAG__HAS_SELF_SIMILARITY = (1 << 20),
+	GIT_DIFF_FLAG__HAS_SELF_SIMILARITY = (1 << 20)
 };
 
 #define GIT_DIFF_FLAG__CLEAR_INTERNAL(F) (F) = ((F) & 0x00FFFF)
@@ -119,8 +119,10 @@ GIT_INLINE(int) git_diff_file__resolve_zero_size(
 
 	git_odb_free(odb);
 
-	if (!error)
+	if (!error) {
 		file->size = (git_object_size_t)len;
+		file->flags |= GIT_DIFF_FLAG_VALID_SIZE;
+	}
 
 	return error;
 }