rugged 1.3.2.3 → 1.4.2

data/vendor/libgit2/src/odb_pack.c

@@ -115,7 +115,7 @@ struct pack_writepack {
  *     | OID can be found. If we can find the offset to that SHA1 inside of the
  *     | index, that means the object is contained inside of the packfile and
  *     | we can stop searching. Before returning, we verify that the
- *     | packfile behing the index we are searching still exists on disk.
+ *     | packfile behind the index we are searching still exists on disk.
  *     |
  *     |-# pack_entry_find_offset
  *       | Mmap the actual index file to disk if it hasn't been opened
@@ -166,7 +166,7 @@ struct pack_writepack {
 
 static int packfile_sort__cb(const void *a_, const void *b_);
 
-static int packfile_load__cb(void *_data, git_buf *path);
+static int packfile_load__cb(void *_data, git_str *path);
 
 static int packfile_byname_search_cmp(const void *path, const void *pack_entry);
 
@@ -195,10 +195,10 @@ static int pack_entry_find_prefix(
 
 static int packfile_byname_search_cmp(const void *path_, const void *p_)
 {
-	const git_buf *path = (const git_buf *)path_;
+	const git_str *path = (const git_str *)path_;
 	const struct git_pack_file *p = (const struct git_pack_file *)p_;
 
-	return strncmp(p->pack_name, git_buf_cstr(path), git_buf_len(path));
+	return strncmp(p->pack_name, git_str_cstr(path), git_str_len(path));
 }
 
 static int packfile_sort__cb(const void *a_, const void *b_)
@@ -231,20 +231,20 @@ static int packfile_sort__cb(const void *a_, const void *b_)
 }
 
 
-static int packfile_load__cb(void *data, git_buf *path)
+static int packfile_load__cb(void *data, git_str *path)
 {
 	struct pack_backend *backend = data;
 	struct git_pack_file *pack;
-	const char *path_str = git_buf_cstr(path);
-	git_buf index_prefix = GIT_BUF_INIT;
-	size_t cmp_len = git_buf_len(path);
+	const char *path_str = git_str_cstr(path);
+	git_str index_prefix = GIT_STR_INIT;
+	size_t cmp_len = git_str_len(path);
 	int error;
 
 	if (cmp_len <= strlen(".idx") || git__suffixcmp(path_str, ".idx") != 0)
 		return 0; /* not an index */
 
 	cmp_len -= strlen(".idx");
-	git_buf_attach_notowned(&index_prefix, path_str, cmp_len);
+	git_str_attach_notowned(&index_prefix, path_str, cmp_len);
 
 	if (git_vector_search2(NULL, &backend->midx_packs, packfile_byname_search_cmp, &index_prefix) == 0)
 		return 0;
@@ -404,29 +404,29 @@ static int process_multi_pack_index_pack(
 	int error;
 	struct git_pack_file *pack;
 	size_t found_position;
-	git_buf pack_path = GIT_BUF_INIT, index_prefix = GIT_BUF_INIT;
+	git_str pack_path = GIT_STR_INIT, index_prefix = GIT_STR_INIT;
 
-	error = git_buf_joinpath(&pack_path, backend->pack_folder, packfile_name);
+	error = git_str_joinpath(&pack_path, backend->pack_folder, packfile_name);
 	if (error < 0)
 		return error;
 
 	/* This is ensured by midx_parse_packfile_name() */
-	if (git_buf_len(&pack_path) <= strlen(".idx") || git__suffixcmp(git_buf_cstr(&pack_path), ".idx") != 0)
+	if (git_str_len(&pack_path) <= strlen(".idx") || git__suffixcmp(git_str_cstr(&pack_path), ".idx") != 0)
 		return git_odb__error_notfound("midx file contained a non-index", NULL, 0);
 
-	git_buf_attach_notowned(&index_prefix, git_buf_cstr(&pack_path), git_buf_len(&pack_path) - strlen(".idx"));
+	git_str_attach_notowned(&index_prefix, git_str_cstr(&pack_path), git_str_len(&pack_path) - strlen(".idx"));
 
 	if (git_vector_search2(&found_position, &backend->packs, packfile_byname_search_cmp, &index_prefix) == 0) {
 		/* Pack was found in the packs list. Moving it to the midx_packs list. */
-		git_buf_dispose(&pack_path);
+		git_str_dispose(&pack_path);
 		git_vector_set(NULL, &backend->midx_packs, i, git_vector_get(&backend->packs, found_position));
 		git_vector_remove(&backend->packs, found_position);
 		return 0;
 	}
 
 	/* Pack was not found. Allocate a new one. */
-	error = git_mwindow_get_pack(&pack, git_buf_cstr(&pack_path));
-	git_buf_dispose(&pack_path);
+	error = git_mwindow_get_pack(&pack, git_str_cstr(&pack_path));
+	git_str_dispose(&pack_path);
 	if (error < 0)
 		return error;
 
@@ -442,11 +442,11 @@ static int process_multi_pack_index_pack(
 static int refresh_multi_pack_index(struct pack_backend *backend)
 {
 	int error;
-	git_buf midx_path = GIT_BUF_INIT;
+	git_str midx_path = GIT_STR_INIT;
 	const char *packfile_name;
 	size_t i;
 
-	error = git_buf_joinpath(&midx_path, backend->pack_folder, "multi-pack-index");
+	error = git_str_joinpath(&midx_path, backend->pack_folder, "multi-pack-index");
 	if (error < 0)
 		return error;
 
@@ -457,19 +457,19 @@ static int refresh_multi_pack_index(struct pack_backend *backend)
 	 * refreshing the new multi-pack-index fails, or the file is deleted.
 	 */
 	if (backend->midx) {
-		if (!git_midx_needs_refresh(backend->midx, git_buf_cstr(&midx_path))) {
-			git_buf_dispose(&midx_path);
+		if (!git_midx_needs_refresh(backend->midx, git_str_cstr(&midx_path))) {
+			git_str_dispose(&midx_path);
 			return 0;
 		}
 		error = remove_multi_pack_index(backend);
 		if (error < 0) {
-			git_buf_dispose(&midx_path);
+			git_str_dispose(&midx_path);
 			return error;
 		}
 	}
 
-	error = git_midx_open(&backend->midx, git_buf_cstr(&midx_path));
-	git_buf_dispose(&midx_path);
+	error = git_midx_open(&backend->midx, git_str_cstr(&midx_path));
+	git_str_dispose(&midx_path);
 	if (error < 0)
 		return error;
 
@@ -505,7 +505,7 @@ static int pack_backend__refresh(git_odb_backend *backend_)
 {
 	int error;
 	struct stat st;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	struct pack_backend *backend = (struct pack_backend *)backend_;
 
 	if (backend->pack_folder == NULL)
@@ -523,10 +523,10 @@ static int pack_backend__refresh(git_odb_backend *backend_)
 	}
 
 	/* reload all packs */
-	git_buf_sets(&path, backend->pack_folder);
-	error = git_path_direach(&path, 0, packfile_load__cb, backend);
+	git_str_sets(&path, backend->pack_folder);
+	error = git_fs_path_direach(&path, 0, packfile_load__cb, backend);
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	git_vector_sort(&backend->packs);
 
 	return error;
@@ -743,21 +743,21 @@ static int pack_backend__writepack(struct git_odb_writepack **out,
 }
 
 static int get_idx_path(
-		git_buf *idx_path,
+		git_str *idx_path,
 		struct pack_backend *backend,
 		struct git_pack_file *p)
 {
 	size_t path_len;
 	int error;
 
-	error = git_path_prettify(idx_path, p->pack_name, backend->pack_folder);
+	error = git_fs_path_prettify(idx_path, p->pack_name, backend->pack_folder);
 	if (error < 0)
 		return error;
-	path_len = git_buf_len(idx_path);
-	if (path_len <= strlen(".pack") || git__suffixcmp(git_buf_cstr(idx_path), ".pack") != 0)
+	path_len = git_str_len(idx_path);
+	if (path_len <= strlen(".pack") || git__suffixcmp(git_str_cstr(idx_path), ".pack") != 0)
 		return git_odb__error_notfound("packfile does not end in .pack", NULL, 0);
 	path_len -= strlen(".pack");
-	error = git_buf_splice(idx_path, path_len, strlen(".pack"), ".idx", strlen(".idx"));
+	error = git_str_splice(idx_path, path_len, strlen(".pack"), ".idx", strlen(".idx"));
 	if (error < 0)
 		return error;
 
@@ -781,22 +781,22 @@ static int pack_backend__writemidx(git_odb_backend *_backend)
 		return error;
 
 	git_vector_foreach(&backend->midx_packs, i, p) {
-		git_buf idx_path = GIT_BUF_INIT;
+		git_str idx_path = GIT_STR_INIT;
 		error = get_idx_path(&idx_path, backend, p);
 		if (error < 0)
 			goto cleanup;
-		error = git_midx_writer_add(w, git_buf_cstr(&idx_path));
-		git_buf_dispose(&idx_path);
+		error = git_midx_writer_add(w, git_str_cstr(&idx_path));
+		git_str_dispose(&idx_path);
 		if (error < 0)
 			goto cleanup;
 	}
 	git_vector_foreach(&backend->packs, i, p) {
-		git_buf idx_path = GIT_BUF_INIT;
+		git_str idx_path = GIT_STR_INIT;
 		error = get_idx_path(&idx_path, backend, p);
 		if (error < 0)
 			goto cleanup;
-		error = git_midx_writer_add(w, git_buf_cstr(&idx_path));
-		git_buf_dispose(&idx_path);
+		error = git_midx_writer_add(w, git_str_cstr(&idx_path));
+		git_str_dispose(&idx_path);
 		if (error < 0)
 			goto cleanup;
 	}
@@ -896,15 +896,15 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir)
 {
 	int error = 0;
 	struct pack_backend *backend = NULL;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 
 	if (pack_backend__alloc(&backend, 8) < 0)
 		return -1;
 
-	if (!(error = git_buf_joinpath(&path, objects_dir, "pack")) &&
-		git_path_isdir(git_buf_cstr(&path)))
+	if (!(error = git_str_joinpath(&path, objects_dir, "pack")) &&
+		git_fs_path_isdir(git_str_cstr(&path)))
 	{
-		backend->pack_folder = git_buf_detach(&path);
+		backend->pack_folder = git_str_detach(&path);
 		error = pack_backend__refresh((git_odb_backend *)backend);
 	}
 
@@ -915,7 +915,7 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir)
 
 	*backend_out = (git_odb_backend *)backend;
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 
 	return error;
 }

data/vendor/libgit2/src/oid.c

@@ -13,6 +13,13 @@
 #include <string.h>
 #include <limits.h>
 
+const git_oid git_oid__empty_blob_sha1 =
+	{{ 0xe6, 0x9d, 0xe2, 0x9b, 0xb2, 0xd1, 0xd6, 0x43, 0x4b, 0x8b,
+	   0x29, 0xae, 0x77, 0x5a, 0xd8, 0xc2, 0xe4, 0x8c, 0x53, 0x91 }};
+const git_oid git_oid__empty_tree_sha1 =
+	{{ 0x4b, 0x82, 0x5d, 0xc6, 0x42, 0xcb, 0x6e, 0xb9, 0xa0, 0x60,
+	   0xe5, 0x4b, 0xf8, 0xd6, 0x92, 0x88, 0xfb, 0xee, 0x49, 0x04 }};
+
 static char to_hex[] = "0123456789abcdef";
 
 static int oid_error_invalid(const char *msg)
@@ -162,14 +169,14 @@ int git_oid__parse(
 	return 0;
 }
 
-void git_oid__writebuf(git_buf *buf, const char *header, const git_oid *oid)
+void git_oid__writebuf(git_str *buf, const char *header, const git_oid *oid)
 {
 	char hex_oid[GIT_OID_HEXSZ];
 
 	git_oid_fmt(hex_oid, oid);
-	git_buf_puts(buf, header);
-	git_buf_put(buf, hex_oid, GIT_OID_HEXSZ);
-	git_buf_putc(buf, '\n');
+	git_str_puts(buf, header);
+	git_str_put(buf, hex_oid, GIT_OID_HEXSZ);
+	git_str_putc(buf, '\n');
 }
 
 int git_oid_fromraw(git_oid *out, const unsigned char *raw)

data/vendor/libgit2/src/oid.h

@@ -11,6 +11,9 @@
 
 #include "git2/oid.h"
 
+extern const git_oid git_oid__empty_blob_sha1;
+extern const git_oid git_oid__empty_tree_sha1;
+
 /**
  * Format a git_oid into a newly allocated c-string.
  *
@@ -48,4 +51,16 @@ GIT_INLINE(void) git_oid__cpy_prefix(
 		out->id[len / 2] &= 0xF0;
 }
 
+GIT_INLINE(bool) git_oid__is_hexstr(const char *str)
+{
+	size_t i;
+
+	for (i = 0; str[i] != '\0'; i++) {
+		if (git__fromhex(str[i]) < 0)
+			return false;
+	}
+
+	return (i == GIT_OID_HEXSZ);
+}
+
 #endif

data/vendor/libgit2/src/pack-objects.c

@@ -7,6 +7,7 @@
 
 #include "pack-objects.h"
 
+#include "buf.h"
 #include "zstream.h"
 #include "delta.h"
 #include "iterator.h"
@@ -33,7 +34,7 @@ struct unpacked {
 
 struct tree_walk_context {
 	git_packbuilder *pb;
-	git_buf buf;
+	git_str buf;
 };
 
 struct pack_write_context {
@@ -141,7 +142,7 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	pb->repo = repo;
 	pb->nr_threads = 1; /* do not spawn any thread by default */
 
-	if (git_hash_ctx_init(&pb->ctx) < 0 ||
+	if (git_hash_ctx_init(&pb->ctx, GIT_HASH_ALGORITHM_SHA1) < 0 ||
 		git_zstream_init(&pb->zstream, GIT_ZSTREAM_DEFLATE) < 0 ||
 		git_repository_odb(&pb->odb, repo) < 0 ||
 		packbuilder_config(pb) < 0)
@@ -664,7 +665,7 @@ static int write_pack(git_packbuilder *pb,
 		pb->nr_remaining -= pb->nr_written;
 	} while (pb->nr_remaining && i < pb->nr_objects);
 
-	if ((error = git_hash_final(&entry_oid, &pb->ctx)) < 0)
+	if ((error = git_hash_final(entry_oid.id, &pb->ctx)) < 0)
 		goto done;
 
 	error = write_cb(entry_oid.id, GIT_OID_RAWSZ, cb_data);
@@ -685,8 +686,8 @@ done:
 
 static int write_pack_buf(void *buf, size_t size, void *data)
 {
-	git_buf *b = (git_buf *)data;
-	return git_buf_put(b, buf, size);
+	git_str *b = (git_str *)data;
+	return git_str_put(b, buf, size);
 }
 
 static int type_size_sort(const void *_a, const void *_b)
@@ -947,7 +948,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 	size_t *list_size, size_t window, size_t depth)
 {
 	git_pobject *po;
-	git_buf zbuf = GIT_BUF_INIT;
+	git_str zbuf = GIT_STR_INIT;
 	struct unpacked *array;
 	size_t idx = 0, count = 0;
 	size_t mem_usage = 0;
@@ -1045,7 +1046,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 
 			memcpy(po->delta_data, zbuf.ptr, zbuf.size);
 			po->z_delta_size = zbuf.size;
-			git_buf_clear(&zbuf);
+			git_str_clear(&zbuf);
 
 			GIT_ASSERT(git_packbuilder__cache_lock(pb) == 0);
 			pb->delta_cache_size -= po->delta_size;
@@ -1093,7 +1094,7 @@ on_error:
 		git__free(array[i].data);
 	}
 	git__free(array);
-	git_buf_dispose(&zbuf);
+	git_str_dispose(&zbuf);
 
 	return error;
 }
@@ -1307,7 +1308,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 #define ll_find_deltas(pb, l, ls, w, d) find_deltas(pb, l, &ls, w, d)
 #endif
 
-static int prepare_pack(git_packbuilder *pb)
+int git_packbuilder__prepare(git_packbuilder *pb)
 {
 	git_pobject **delta_list;
 	size_t i, n = 0;
@@ -1352,7 +1353,7 @@ static int prepare_pack(git_packbuilder *pb)
 	return 0;
 }
 
-#define PREPARE_PACK if (prepare_pack(pb) < 0) { return -1; }
+#define PREPARE_PACK if (git_packbuilder__prepare(pb) < 0) { return -1; }
 
 int git_packbuilder_foreach(git_packbuilder *pb, int (*cb)(void *buf, size_t size, void *payload), void *payload)
 {
@@ -1360,18 +1361,18 @@ int git_packbuilder_foreach(git_packbuilder *pb, int (*cb)(void *buf, size_t siz
 	return write_pack(pb, cb, payload);
 }
 
-int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb)
+int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb)
 {
-	int error;
-
-	if ((error = git_buf_sanitize(buf)) < 0)
-		return error;
-
 	PREPARE_PACK;
 
 	return write_pack(pb, &write_pack_buf, buf);
 }
 
+int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb)
+{
+	GIT_BUF_WRAP_PRIVATE(buf, git_packbuilder__write_buf, pb);
+}
+
 static int write_cb(void *buf, size_t len, void *payload)
 {
 	struct pack_write_context *ctx = payload;
@@ -1386,7 +1387,7 @@ int git_packbuilder_write(
 	void *progress_cb_payload)
 {
 	int error = -1;
-	git_buf object_path = GIT_BUF_INIT;
+	git_str object_path = GIT_STR_INIT;
 	git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT;
 	git_indexer *indexer = NULL;
 	git_indexer_progress stats;
@@ -1396,11 +1397,11 @@ int git_packbuilder_write(
 	PREPARE_PACK;
 
 	if (path == NULL) {
-		if ((error = git_repository_item_path(&object_path, pb->repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0)
+		if ((error = git_repository__item_path(&object_path, pb->repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0)
 			goto cleanup;
-		if ((error = git_buf_joinpath(&object_path, git_buf_cstr(&object_path), "pack")) < 0)
+		if ((error = git_str_joinpath(&object_path, git_str_cstr(&object_path), "pack")) < 0)
 			goto cleanup;
-		path = git_buf_cstr(&object_path);
+		path = git_str_cstr(&object_path);
 	}
 
 	opts.progress_cb = progress_cb;
@@ -1421,20 +1422,32 @@ int git_packbuilder_write(
 	if ((error = git_indexer_commit(indexer, &stats)) < 0)
 		goto cleanup;
 
+#ifndef GIT_DEPRECATE_HARD
 	git_oid_cpy(&pb->pack_oid, git_indexer_hash(indexer));
+#endif
+
+	pb->pack_name = git__strdup(git_indexer_name(indexer));
+	GIT_ERROR_CHECK_ALLOC(pb->pack_name);
 
 cleanup:
 	git_indexer_free(indexer);
-	git_buf_dispose(&object_path);
+	git_str_dispose(&object_path);
 	return error;
 }
 
 #undef PREPARE_PACK
 
+#ifndef GIT_DEPRECATE_HARD
 const git_oid *git_packbuilder_hash(git_packbuilder *pb)
 {
 	return &pb->pack_oid;
 }
+#endif
+
+const char *git_packbuilder_name(git_packbuilder *pb)
+{
+	return pb->pack_name;
+}
 
 
 static int cb_tree_walk(
@@ -1447,10 +1460,10 @@ static int cb_tree_walk(
 	if (git_tree_entry_type(entry) == GIT_OBJECT_COMMIT)
 		return 0;
 
-	if (!(error = git_buf_sets(&ctx->buf, root)) &&
-		!(error = git_buf_puts(&ctx->buf, git_tree_entry_name(entry))))
+	if (!(error = git_str_sets(&ctx->buf, root)) &&
+		!(error = git_str_puts(&ctx->buf, git_tree_entry_name(entry))))
 		error = git_packbuilder_insert(
-			ctx->pb, git_tree_entry_id(entry), git_buf_cstr(&ctx->buf));
+			ctx->pb, git_tree_entry_id(entry), git_str_cstr(&ctx->buf));
 
 	return error;
 }
@@ -1474,14 +1487,14 @@ int git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *oid)
 {
 	int error;
 	git_tree *tree = NULL;
-	struct tree_walk_context context = { pb, GIT_BUF_INIT };
+	struct tree_walk_context context = { pb, GIT_STR_INIT };
 
 	if (!(error = git_tree_lookup(&tree, pb->repo, oid)) &&
 	    !(error = git_packbuilder_insert(pb, oid, NULL)))
 		error = git_tree_walk(tree, GIT_TREEWALK_PRE, cb_tree_walk, &context);
 
 	git_tree_free(tree);
-	git_buf_dispose(&context.buf);
+	git_str_dispose(&context.buf);
 	return error;
 }
 
@@ -1802,5 +1815,7 @@ void git_packbuilder_free(git_packbuilder *pb)
 	git_hash_ctx_cleanup(&pb->ctx);
 	git_zstream_free(&pb->zstream);
 
+	git__free(pb->pack_name);
+
 	git__free(pb);
 }

data/vendor/libgit2/src/pack-objects.h

@@ -10,7 +10,7 @@
 
 #include "common.h"
 
-#include "buffer.h"
+#include "str.h"
 #include "hash.h"
 #include "oidmap.h"
 #include "netops.h"
@@ -46,10 +46,10 @@ typedef struct git_pobject {
 	size_t delta_size;
 	size_t z_delta_size;
 
-	int written:1,
-	    recursing:1,
-	    tagged:1,
-	    filled:1;
+	unsigned int written:1,
+	             recursing:1,
+	             tagged:1,
+	             filled:1;
 } git_pobject;
 
 struct git_packbuilder {
@@ -73,7 +73,10 @@ struct git_packbuilder {
 	git_oidmap *walk_objects;
 	git_pool object_pool;
 
+#ifndef GIT_DEPRECATE_HARD
 	git_oid pack_oid; /* hash of written pack */
+#endif
+	char *pack_name; /* name of written pack */
 
 	/* synchronization objects */
 	git_mutex cache_mutex;
@@ -96,6 +99,8 @@ struct git_packbuilder {
 	bool done;
 };
 
-int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb);
+int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb);
+int git_packbuilder__prepare(git_packbuilder *pb);
+
 
 #endif

data/vendor/libgit2/src/pack.c

@@ -308,7 +308,7 @@ static int pack_index_open_locked(struct git_pack_file *p)
 {
 	int error = 0;
 	size_t name_len;
-	git_buf idx_name = GIT_BUF_INIT;
+	git_str idx_name = GIT_STR_INIT;
 
 	if (p->index_version > -1)
 		goto cleanup;
@@ -317,12 +317,12 @@ static int pack_index_open_locked(struct git_pack_file *p)
 	name_len = strlen(p->pack_name);
 	GIT_ASSERT(name_len > strlen(".pack"));
 
-	if ((error = git_buf_init(&idx_name, name_len)) < 0)
+	if ((error = git_str_init(&idx_name, name_len)) < 0)
 		goto cleanup;
 
-	git_buf_put(&idx_name, p->pack_name, name_len - strlen(".pack"));
-	git_buf_puts(&idx_name, ".idx");
-	if (git_buf_oom(&idx_name)) {
+	git_str_put(&idx_name, p->pack_name, name_len - strlen(".pack"));
+	git_str_puts(&idx_name, ".idx");
+	if (git_str_oom(&idx_name)) {
 		error = -1;
 		goto cleanup;
 	}
@@ -331,7 +331,7 @@ static int pack_index_open_locked(struct git_pack_file *p)
 		error = pack_index_check_locked(idx_name.ptr, p);
 
 cleanup:
-	git_buf_dispose(&idx_name);
+	git_str_dispose(&idx_name);
 
 	return error;
 }
@@ -1156,17 +1156,17 @@ cleanup:
 int git_packfile__name(char **out, const char *path)
 {
 	size_t path_len;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 
 	path_len = strlen(path);
 
 	if (path_len < strlen(".idx"))
 		return git_odb__error_notfound("invalid packfile path", NULL, 0);
 
-	if (git_buf_printf(&buf, "%.*s.pack", (int)(path_len - strlen(".idx")), path) < 0)
+	if (git_str_printf(&buf, "%.*s.pack", (int)(path_len - strlen(".idx")), path) < 0)
 		return -1;
 
-	*out = git_buf_detach(&buf);
+	*out = git_str_detach(&buf);
 	return 0;
 }
 
@@ -1198,7 +1198,7 @@ int git_packfile_alloc(struct git_pack_file **pack_out, const char *path)
 
 		if (!git_disable_pack_keep_file_checks) {
 			memcpy(p->pack_name + root_len, ".keep", sizeof(".keep"));
-			if (git_path_exists(p->pack_name) == true)
+			if (git_fs_path_exists(p->pack_name) == true)
 				p->pack_keep = 1;
 		}
 

data/vendor/libgit2/src/patch.c

@@ -76,15 +76,15 @@ size_t git_patch_size(
 		out += patch->header_size;
 
 	if (include_file_headers) {
-		git_buf file_header = GIT_BUF_INIT;
+		git_str file_header = GIT_STR_INIT;
 
 		if (git_diff_delta__format_file_header(
 			&file_header, patch->delta, NULL, NULL, 0, true) < 0)
 			git_error_clear();
 		else
-			out += git_buf_len(&file_header);
+			out += git_str_len(&file_header);
 
-		git_buf_dispose(&file_header);
+		git_str_dispose(&file_header);
 	}
 
 	return out;

data/vendor/libgit2/src/patch.h

@@ -63,6 +63,7 @@ typedef struct {
 
 #define GIT_PATCH_OPTIONS_INIT { 1 }
 
+extern int git_patch__to_buf(git_str *out, git_patch *patch);
 extern void git_patch_free(git_patch *patch);
 
 #endif