rugged 1.3.2 → 1.6.2

data/vendor/libgit2/src/libgit2/buf.c

@@ -0,0 +1,126 @@
+/*
+ * 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.
+ */
+
+#include "buf.h"
+#include "common.h"
+
+int git_buf_sanitize(git_buf *buf)
+{
+	GIT_ASSERT_ARG(buf);
+
+	if (buf->reserved > 0)
+		buf->ptr[0] = '\0';
+	else
+		buf->ptr = git_str__initstr;
+
+	buf->size = 0;
+	return 0;
+}
+
+int git_buf_tostr(git_str *out, git_buf *buf)
+{
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(buf);
+
+	if (git_buf_sanitize(buf) < 0)
+		return -1;
+
+	out->ptr = buf->ptr;
+	out->asize = buf->reserved;
+	out->size = buf->size;
+
+	buf->ptr = git_str__initstr;
+	buf->reserved = 0;
+	buf->size = 0;
+
+	return 0;
+}
+
+int git_buf_fromstr(git_buf *out, git_str *str)
+{
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(str);
+
+	out->ptr = str->ptr;
+	out->reserved = str->asize;
+	out->size = str->size;
+
+	str->ptr = git_str__initstr;
+	str->asize = 0;
+	str->size = 0;
+
+	return 0;
+}
+
+void git_buf_dispose(git_buf *buf)
+{
+	if (!buf)
+		return;
+
+	if (buf->ptr != git_str__initstr)
+		git__free(buf->ptr);
+
+	buf->ptr = git_str__initstr;
+	buf->reserved = 0;
+	buf->size = 0;
+}
+
+#ifndef GIT_DEPRECATE_HARD
+int git_buf_grow(git_buf *buffer, size_t target_size)
+{
+	char *newptr;
+
+	if (buffer->reserved >= target_size)
+		return 0;
+
+	if (buffer->ptr == git_str__initstr)
+		newptr = git__malloc(target_size);
+	else
+		newptr = git__realloc(buffer->ptr, target_size);
+
+	if (!newptr)
+		return -1;
+
+	buffer->ptr = newptr;
+	buffer->reserved = target_size;
+	return 0;
+}
+
+int git_buf_set(git_buf *buffer, const void *data, size_t datalen)
+{
+	size_t alloclen;
+
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, datalen, 1);
+
+	if (git_buf_grow(buffer, alloclen) < 0)
+		return -1;
+
+	memmove(buffer->ptr, data, datalen);
+	buffer->size = datalen;
+	buffer->ptr[buffer->size] = '\0';
+
+	return 0;
+}
+
+int git_buf_is_binary(const git_buf *buf)
+{
+	git_str str = GIT_STR_INIT_CONST(buf->ptr, buf->size);
+	return git_str_is_binary(&str);
+}
+
+int git_buf_contains_nul(const git_buf *buf)
+{
+	git_str str = GIT_STR_INIT_CONST(buf->ptr, buf->size);
+	return git_str_contains_nul(&str);
+}
+
+void git_buf_free(git_buf *buffer)
+{
+	git_buf_dispose(buffer);
+}
+
+#endif

data/vendor/libgit2/src/libgit2/buf.h

@@ -0,0 +1,50 @@
+/*
+ * 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_buf_h__
+#define INCLUDE_buf_h__
+
+#include "git2/buffer.h"
+#include "common.h"
+
+/*
+ * Adapts a private API that takes a `git_str` into a public API that
+ * takes a `git_buf`.
+ */
+
+#define GIT_BUF_WRAP_PRIVATE(buf, fn, ...) \
+  { \
+	git_str str = GIT_STR_INIT; \
+	int error; \
+	if ((error = git_buf_tostr(&str, buf)) == 0 && \
+	    (error = fn(&str, __VA_ARGS__)) == 0) \
+		error = git_buf_fromstr(buf, &str); \
+	git_str_dispose(&str); \
+	return error; \
+}
+
+/**
+ * "Sanitizes" a buffer from user input.  This simply ensures that the
+ * `git_buf` has nice defaults if the user didn't set the members to
+ * anything, so that if we return early we don't leave it populated
+ * with nonsense.
+ */
+extern int git_buf_sanitize(git_buf *from_user);
+
+/**
+ * Populate a `git_str` from a `git_buf` for passing to libgit2 internal
+ * functions.  Sanitizes the given `git_buf` before proceeding.  The
+ * `git_buf` will no longer point to this memory.
+ */
+extern int git_buf_tostr(git_str *out, git_buf *buf);
+
+/**
+ * Populate a `git_buf` from a `git_str` for returning to a user.
+ * The `git_str` will no longer point to this memory.
+ */
+extern int git_buf_fromstr(git_buf *out, git_str *str);
+
+#endif

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

@@ -27,10 +27,11 @@
 #include "diff_generate.h"
 #include "pathspec.h"
 #include "diff_xdiff.h"
-#include "path.h"
+#include "fs_path.h"
 #include "attr.h"
 #include "pool.h"
 #include "strmap.h"
+#include "path.h"
 
 /* See docs/checkout-internals.md for more information */
 
@@ -44,7 +45,7 @@ enum {
 	CHECKOUT_ACTION__UPDATE_CONFLICT = 32,
 	CHECKOUT_ACTION__MAX = 32,
 	CHECKOUT_ACTION__REMOVE_AND_UPDATE =
-		(CHECKOUT_ACTION__UPDATE_BLOB | CHECKOUT_ACTION__REMOVE),
+		(CHECKOUT_ACTION__UPDATE_BLOB | CHECKOUT_ACTION__REMOVE)
 };
 
 typedef struct {
@@ -61,9 +62,9 @@ typedef struct {
 	git_vector update_conflicts;
 	git_vector *update_reuc;
 	git_vector *update_names;
-	git_buf target_path;
+	git_str target_path;
 	size_t target_len;
-	git_buf tmp;
+	git_str tmp;
 	unsigned int strategy;
 	int can_symlink;
 	int respect_filemode;
@@ -80,11 +81,11 @@ typedef struct {
 	const git_index_entry *ours;
 	const git_index_entry *theirs;
 
-	int name_collision:1,
-		directoryfile:1,
-		one_to_two:1,
-		binary:1,
-		submodule:1;
+	unsigned int name_collision:1,
+	             directoryfile:1,
+	             one_to_two:1,
+	             binary:1,
+	             submodule:1;
 } checkout_conflictdata;
 
 static int checkout_notify(
@@ -321,14 +322,14 @@ static int checkout_action_no_wd(
 }
 
 static int checkout_target_fullpath(
-	git_buf **out, checkout_data *data, const char *path)
+	git_str **out, checkout_data *data, const char *path)
 {
-	git_buf_truncate(&data->target_path, data->target_len);
+	git_str_truncate(&data->target_path, data->target_len);
 
-	if (path && git_buf_puts(&data->target_path, path) < 0)
+	if (path && git_str_puts(&data->target_path, path) < 0)
 		return -1;
 
-	if (git_path_validate_workdir_buf(data->repo, &data->target_path) < 0)
+	if (git_path_validate_str_length(data->repo, &data->target_path) < 0)
 		return -1;
 
 	*out = &data->target_path;
@@ -339,7 +340,7 @@ static int checkout_target_fullpath(
 static bool wd_item_is_removable(
 	checkout_data *data, const git_index_entry *wd)
 {
-	git_buf *full;
+	git_str *full;
 
 	if (wd->mode != GIT_FILEMODE_TREE)
 		return true;
@@ -347,7 +348,7 @@ static bool wd_item_is_removable(
 	if (checkout_target_fullpath(&full, data, wd->path) < 0)
 		return false;
 
-	return !full || !git_path_contains(full, DOT_GIT);
+	return !full || !git_fs_path_contains(full, DOT_GIT);
 }
 
 static int checkout_queue_remove(checkout_data *data, const char *path)
@@ -423,7 +424,7 @@ static int checkout_action_wd_only(
 
 		/* copy the entry for issuing notification callback later */
 		git_index_entry saved_wd = *wd;
-		git_buf_sets(&data->tmp, wd->path);
+		git_str_sets(&data->tmp, wd->path);
 		saved_wd.path = data->tmp.ptr;
 
 		error = git_iterator_advance_over(
@@ -476,12 +477,12 @@ static bool submodule_is_config_only(
 
 static bool checkout_is_empty_dir(checkout_data *data, const char *path)
 {
-	git_buf *fullpath;
+	git_str *fullpath;
 
 	if (checkout_target_fullpath(&fullpath, data, path) < 0)
 		return false;
 
-	return git_path_is_empty_dir(fullpath->ptr);
+	return git_fs_path_is_empty_dir(fullpath->ptr);
 }
 
 static int checkout_action_with_wd(
@@ -962,7 +963,7 @@ static int checkout_conflicts_load(checkout_data *data, git_iterator *workdir, g
 {
 	git_index *index;
 
-	/* Only write conficts from sources that have them: indexes. */
+	/* Only write conflicts from sources that have them: indexes. */
 	if ((index = git_iterator_index(data->target)) == NULL)
 		return 0;
 
@@ -1201,12 +1202,12 @@ static int checkout_conflicts_mark_directoryfile(
 				goto done;
 			}
 
-			prefixed = git_path_equal_or_prefixed(path, entry->path, NULL);
+			prefixed = git_fs_path_equal_or_prefixed(path, entry->path, NULL);
 
-			if (prefixed == GIT_PATH_EQUAL)
+			if (prefixed == GIT_FS_PATH_EQUAL)
 				continue;
 
-			if (prefixed == GIT_PATH_PREFIX)
+			if (prefixed == GIT_FS_PATH_PREFIX)
 				conflict->directoryfile = 1;
 
 			break;
@@ -1280,14 +1281,14 @@ static int checkout_verify_paths(
 	unsigned int flags = GIT_PATH_REJECT_WORKDIR_DEFAULTS;
 
 	if (action & CHECKOUT_ACTION__REMOVE) {
-		if (!git_path_validate(repo, delta->old_file.path, delta->old_file.mode, flags)) {
+		if (!git_path_is_valid(repo, delta->old_file.path, delta->old_file.mode, flags)) {
 			git_error_set(GIT_ERROR_CHECKOUT, "cannot remove invalid path '%s'", delta->old_file.path);
 			return -1;
 		}
 	}
 
 	if (action & ~CHECKOUT_ACTION__REMOVE) {
-		if (!git_path_validate(repo, delta->new_file.path, delta->new_file.mode, flags)) {
+		if (!git_path_is_valid(repo, delta->new_file.path, delta->new_file.mode, flags)) {
 			git_error_set(GIT_ERROR_CHECKOUT, "cannot checkout to invalid path '%s'", delta->new_file.path);
 			return -1;
 		}
@@ -1584,7 +1585,7 @@ static int blob_content_to_link(
 	git_blob *blob,
 	const char *path)
 {
-	git_buf linktarget = GIT_BUF_INIT;
+	git_str linktarget = GIT_STR_INIT;
 	int error;
 
 	if ((error = mkpath2file(data, path, data->opts.dir_mode)) < 0)
@@ -1594,10 +1595,10 @@ static int blob_content_to_link(
 		return error;
 
 	if (data->can_symlink) {
-		if ((error = p_symlink(git_buf_cstr(&linktarget), path)) < 0)
+		if ((error = p_symlink(git_str_cstr(&linktarget), path)) < 0)
 			git_error_set(GIT_ERROR_OS, "could not create symlink %s", path);
 	} else {
-		error = git_futils_fake_symlink(git_buf_cstr(&linktarget), path);
+		error = git_futils_fake_symlink(git_str_cstr(&linktarget), path);
 	}
 
 	if (!error) {
@@ -1609,7 +1610,7 @@ static int blob_content_to_link(
 		st->st_mode = GIT_FILEMODE_LINK;
 	}
 
-	git_buf_dispose(&linktarget);
+	git_str_dispose(&linktarget);
 
 	return error;
 }
@@ -1636,7 +1637,7 @@ static int checkout_submodule_update_index(
 	checkout_data *data,
 	const git_diff_file *file)
 {
-	git_buf *fullpath;
+	git_str *fullpath;
 	struct stat st;
 
 	/* update the index unless prevented */
@@ -1772,7 +1773,7 @@ static int checkout_blob(
 	checkout_data *data,
 	const git_diff_file *file)
 {
-	git_buf *fullpath;
+	git_str *fullpath;
 	struct stat st;
 	int error = 0;
 
@@ -1809,7 +1810,7 @@ static int checkout_remove_the_old(
 	git_diff_delta *delta;
 	const char *str;
 	size_t i;
-	git_buf *fullpath;
+	git_str *fullpath;
 	uint32_t flg = GIT_RMDIR_EMPTY_PARENTS |
 		GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS;
 
@@ -1927,40 +1928,40 @@ static int checkout_lookup_head_tree(git_tree **out, git_repository *repo)
 
 
 static int conflict_entry_name(
-	git_buf *out,
+	git_str *out,
 	const char *side_name,
 	const char *filename)
 {
-	if (git_buf_puts(out, side_name) < 0 ||
-		git_buf_putc(out, ':') < 0 ||
-		git_buf_puts(out, filename) < 0)
+	if (git_str_puts(out, side_name) < 0 ||
+		git_str_putc(out, ':') < 0 ||
+		git_str_puts(out, filename) < 0)
 		return -1;
 
 	return 0;
 }
 
-static int checkout_path_suffixed(git_buf *path, const char *suffix)
+static int checkout_path_suffixed(git_str *path, const char *suffix)
 {
 	size_t path_len;
 	int i = 0, error = 0;
 
-	if ((error = git_buf_putc(path, '~')) < 0 || (error = git_buf_puts(path, suffix)) < 0)
+	if ((error = git_str_putc(path, '~')) < 0 || (error = git_str_puts(path, suffix)) < 0)
 		return -1;
 
-	path_len = git_buf_len(path);
+	path_len = git_str_len(path);
 
-	while (git_path_exists(git_buf_cstr(path)) && i < INT_MAX) {
-		git_buf_truncate(path, path_len);
+	while (git_fs_path_exists(git_str_cstr(path)) && i < INT_MAX) {
+		git_str_truncate(path, path_len);
 
-		if ((error = git_buf_putc(path, '_')) < 0 ||
-			(error = git_buf_printf(path, "%d", i)) < 0)
+		if ((error = git_str_putc(path, '_')) < 0 ||
+			(error = git_str_printf(path, "%d", i)) < 0)
 			return error;
 
 		i++;
 	}
 
 	if (i == INT_MAX) {
-		git_buf_truncate(path, path_len);
+		git_str_truncate(path, path_len);
 
 		git_error_set(GIT_ERROR_CHECKOUT, "could not write '%s': working directory file exists", path->ptr);
 		return GIT_EEXISTS;
@@ -1974,8 +1975,8 @@ static int checkout_write_entry(
 	checkout_conflictdata *conflict,
 	const git_index_entry *side)
 {
-	const char *hint_path, *suffix;
-	git_buf *fullpath;
+	const char *hint_path = NULL, *suffix;
+	git_str *fullpath;
 	struct stat st;
 	int error;
 
@@ -2025,7 +2026,7 @@ static int checkout_write_entries(
 }
 
 static int checkout_merge_path(
-	git_buf *out,
+	git_str *out,
 	checkout_data *data,
 	checkout_conflictdata *conflict,
 	git_merge_file_result *result)
@@ -2033,8 +2034,8 @@ static int checkout_merge_path(
 	const char *our_label_raw, *their_label_raw, *suffix;
 	int error = 0;
 
-	if ((error = git_buf_joinpath(out, data->opts.target_directory, result->path)) < 0 ||
-	    (error = git_path_validate_workdir_buf(data->repo, out)) < 0)
+	if ((error = git_str_joinpath(out, data->opts.target_directory, result->path)) < 0 ||
+	    (error = git_path_validate_str_length(data->repo, out)) < 0)
 		return error;
 
 	/* Most conflicts simply use the filename in the index */
@@ -2056,9 +2057,9 @@ static int checkout_write_merge(
 	checkout_data *data,
 	checkout_conflictdata *conflict)
 {
-	git_buf our_label = GIT_BUF_INIT, their_label = GIT_BUF_INIT,
-		path_suffixed = GIT_BUF_INIT, path_workdir = GIT_BUF_INIT,
-		in_data = GIT_BUF_INIT, out_data = GIT_BUF_INIT;
+	git_str our_label = GIT_STR_INIT, their_label = GIT_STR_INIT,
+		path_suffixed = GIT_STR_INIT, path_workdir = GIT_STR_INIT,
+		in_data = GIT_STR_INIT, out_data = GIT_STR_INIT;
 	git_merge_file_options opts = GIT_MERGE_FILE_OPTIONS_INIT;
 	git_merge_file_result result = {0};
 	git_filebuf output = GIT_FILEBUF_INIT;
@@ -2069,6 +2070,9 @@ static int checkout_write_merge(
 	if (data->opts.checkout_strategy & GIT_CHECKOUT_CONFLICT_STYLE_DIFF3)
 		opts.flags |= GIT_MERGE_FILE_STYLE_DIFF3;
 
+	if (data->opts.checkout_strategy & GIT_CHECKOUT_CONFLICT_STYLE_ZDIFF3)
+		opts.flags |= GIT_MERGE_FILE_STYLE_ZDIFF3;
+
 	opts.ancestor_label = data->opts.ancestor_label ?
 		data->opts.ancestor_label : "ancestor";
 	opts.our_label = data->opts.our_label ?
@@ -2088,8 +2092,8 @@ static int checkout_write_merge(
 			&their_label, opts.their_label, conflict->theirs->path)) < 0)
 			goto done;
 
-		opts.our_label = git_buf_cstr(&our_label);
-		opts.their_label = git_buf_cstr(&their_label);
+		opts.our_label = git_str_cstr(&our_label);
+		opts.their_label = git_str_cstr(&their_label);
 	}
 
 	if ((error = git_merge_file_from_index(&result, data->repo,
@@ -2106,7 +2110,7 @@ static int checkout_write_merge(
 		goto done;
 
 	if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0 &&
-		(error = checkout_safe_for_update_only(data, git_buf_cstr(&path_workdir), result.mode)) <= 0)
+		(error = checkout_safe_for_update_only(data, git_str_cstr(&path_workdir), result.mode)) <= 0)
 		goto done;
 
 	if (!data->opts.disable_filters) {
@@ -2127,7 +2131,7 @@ static int checkout_write_merge(
 	}
 
 	if ((error = mkpath2file(data, path_workdir.ptr, data->opts.dir_mode)) < 0 ||
-		(error = git_filebuf_open(&output, git_buf_cstr(&path_workdir), GIT_FILEBUF_DO_NOT_BUFFER, result.mode)) < 0 ||
+		(error = git_filebuf_open(&output, git_str_cstr(&path_workdir), GIT_FILEBUF_DO_NOT_BUFFER, result.mode)) < 0 ||
 		(error = git_filebuf_write(&output, out_data.ptr, out_data.size)) < 0 ||
 		(error = git_filebuf_commit(&output)) < 0)
 		goto done;
@@ -2135,13 +2139,13 @@ static int checkout_write_merge(
 done:
 	git_filter_list_free(fl);
 
-	git_buf_dispose(&out_data);
-	git_buf_dispose(&our_label);
-	git_buf_dispose(&their_label);
+	git_str_dispose(&out_data);
+	git_str_dispose(&our_label);
+	git_str_dispose(&their_label);
 
 	git_merge_file_result_free(&result);
-	git_buf_dispose(&path_workdir);
-	git_buf_dispose(&path_suffixed);
+	git_str_dispose(&path_workdir);
+	git_str_dispose(&path_suffixed);
 
 	return error;
 }
@@ -2321,8 +2325,8 @@ static void checkout_data_clear(checkout_data *data)
 	git__free(data->pfx);
 	data->pfx = NULL;
 
-	git_buf_dispose(&data->target_path);
-	git_buf_dispose(&data->tmp);
+	git_str_dispose(&data->target_path);
+	git_str_dispose(&data->tmp);
 
 	git_index_free(data->index);
 	data->index = NULL;
@@ -2337,10 +2341,10 @@ static int validate_target_directory(checkout_data *data)
 {
 	int error;
 
-	if ((error = git_path_validate_workdir(data->repo, data->opts.target_directory)) < 0)
+	if ((error = git_path_validate_length(data->repo, data->opts.target_directory)) < 0)
 		return error;
 
-	if (git_path_isdir(data->opts.target_directory))
+	if (git_fs_path_isdir(data->opts.target_directory))
 		return 0;
 
 	error = checkout_mkdir(data, data->opts.target_directory, NULL,
@@ -2492,6 +2496,8 @@ static int checkout_data_init(
 			data->opts.checkout_strategy |= GIT_CHECKOUT_CONFLICT_STYLE_MERGE;
 		else if (strcmp(conflict_style->value, "diff3") == 0)
 			data->opts.checkout_strategy |= GIT_CHECKOUT_CONFLICT_STYLE_DIFF3;
+		else if (strcmp(conflict_style->value, "zdiff3") == 0)
+			data->opts.checkout_strategy |= GIT_CHECKOUT_CONFLICT_STYLE_ZDIFF3;
 		else {
 			git_error_set(GIT_ERROR_CHECKOUT, "unknown style '%s' given for 'merge.conflictstyle'",
 				conflict_style->value);
@@ -2506,12 +2512,12 @@ static int checkout_data_init(
 	    (error = git_vector_init(&data->removes, 0, git__strcmp_cb)) < 0 ||
 	    (error = git_vector_init(&data->remove_conflicts, 0, NULL)) < 0 ||
 	    (error = git_vector_init(&data->update_conflicts, 0, NULL)) < 0 ||
-	    (error = git_buf_puts(&data->target_path, data->opts.target_directory)) < 0 ||
-	    (error = git_path_to_dir(&data->target_path)) < 0 ||
+	    (error = git_str_puts(&data->target_path, data->opts.target_directory)) < 0 ||
+	    (error = git_fs_path_to_dir(&data->target_path)) < 0 ||
 	    (error = git_strmap_new(&data->mkdir_map)) < 0)
 		goto cleanup;
 
-	data->target_len = git_buf_len(&data->target_path);
+	data->target_len = git_str_len(&data->target_path);
 
 	git_attr_session__init(&data->attr_session, data->repo);
 
@@ -2623,7 +2629,7 @@ int git_checkout_iterator(
 
 	if (data.strategy & GIT_CHECKOUT_DRY_RUN)
 		goto cleanup;
-	
+
 	data.total_steps = counts[CHECKOUT_ACTION__REMOVE] +
 		counts[CHECKOUT_ACTION__REMOVE_CONFLICT] +
 		counts[CHECKOUT_ACTION__UPDATE_BLOB] +

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

@@ -26,10 +26,10 @@ static int write_cherrypick_head(
 	const char *commit_oidstr)
 {
 	git_filebuf file = GIT_FILEBUF_INIT;
-	git_buf file_path = GIT_BUF_INIT;
+	git_str file_path = GIT_STR_INIT;
 	int error = 0;
 
-	if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_CHERRYPICK_HEAD_FILE)) >= 0 &&
+	if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_CHERRYPICK_HEAD_FILE)) >= 0 &&
 		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_CHERRYPICK_FILE_MODE)) >= 0 &&
 		(error = git_filebuf_printf(&file, "%s\n", commit_oidstr)) >= 0)
 		error = git_filebuf_commit(&file);
@@ -37,7 +37,7 @@ static int write_cherrypick_head(
 	if (error < 0)
 		git_filebuf_cleanup(&file);
 
-	git_buf_dispose(&file_path);
+	git_str_dispose(&file_path);
 
 	return error;
 }
@@ -47,10 +47,10 @@ static int write_merge_msg(
 	const char *commit_msg)
 {
 	git_filebuf file = GIT_FILEBUF_INIT;
-	git_buf file_path = GIT_BUF_INIT;
+	git_str file_path = GIT_STR_INIT;
 	int error = 0;
 
-	if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 ||
+	if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 ||
 		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_CHERRYPICK_FILE_MODE)) < 0 ||
 		(error = git_filebuf_printf(&file, "%s", commit_msg)) < 0)
 		goto cleanup;
@@ -61,7 +61,7 @@ cleanup:
 	if (error < 0)
 		git_filebuf_cleanup(&file);
 
-	git_buf_dispose(&file_path);
+	git_str_dispose(&file_path);
 
 	return error;
 }
@@ -106,10 +106,10 @@ static int cherrypick_state_cleanup(git_repository *repo)
 
 static int cherrypick_seterr(git_commit *commit, const char *fmt)
 {
-	char commit_oidstr[GIT_OID_HEXSZ + 1];
+	char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
 
 	git_error_set(GIT_ERROR_CHERRYPICK, fmt,
-		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)));
 
 	return -1;
 }
@@ -173,9 +173,9 @@ int git_cherrypick(
 	git_cherrypick_options opts;
 	git_reference *our_ref = NULL;
 	git_commit *our_commit = NULL;
-	char commit_oidstr[GIT_OID_HEXSZ + 1];
+	char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
 	const char *commit_msg, *commit_summary;
-	git_buf their_label = GIT_BUF_INIT;
+	git_str their_label = GIT_STR_INIT;
 	git_index *index = NULL;
 	git_indexwriter indexwriter = GIT_INDEXWRITER_INIT;
 	int error = 0;
@@ -197,8 +197,8 @@ int git_cherrypick(
 	git_oid_nfmt(commit_oidstr, sizeof(commit_oidstr), git_commit_id(commit));
 
 	if ((error = write_merge_msg(repo, commit_msg)) < 0 ||
-		(error = git_buf_printf(&their_label, "%.7s... %s", commit_oidstr, commit_summary)) < 0 ||
-		(error = cherrypick_normalize_opts(repo, &opts, given_opts, git_buf_cstr(&their_label))) < 0 ||
+		(error = git_str_printf(&their_label, "%.7s... %s", commit_oidstr, commit_summary)) < 0 ||
+		(error = cherrypick_normalize_opts(repo, &opts, given_opts, git_str_cstr(&their_label))) < 0 ||
 		(error = git_indexwriter_init_for_operation(&indexwriter, repo, &opts.checkout_opts.checkout_strategy)) < 0 ||
 		(error = write_cherrypick_head(repo, commit_oidstr)) < 0 ||
 		(error = git_repository_head(&our_ref, repo)) < 0 ||
@@ -220,7 +220,7 @@ done:
 	git_index_free(index);
 	git_commit_free(our_commit);
 	git_reference_free(our_ref);
-	git_buf_dispose(&their_label);
+	git_str_dispose(&their_label);
 
 	return error;
 }