rugged 1.3.2 → 1.6.2

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

@@ -7,10 +7,11 @@
 
 #include "common.h"
 
-#include "buffer.h"
+#include "str.h"
 #include "repository.h"
 #include "posix.h"
 #include "filebuf.h"
+#include "commit.h"
 #include "merge.h"
 #include "array.h"
 #include "config.h"
@@ -34,6 +35,7 @@
 #define ONTO_FILE           "onto"
 #define ONTO_NAME_FILE      "onto_name"
 #define QUIET_FILE          "quiet"
+#define INTERACTIVE_FILE    "interactive"
 
 #define MSGNUM_FILE         "msgnum"
 #define END_FILE            "end"
@@ -52,7 +54,7 @@ typedef enum {
 	GIT_REBASE_NONE = 0,
 	GIT_REBASE_APPLY = 1,
 	GIT_REBASE_MERGE = 2,
-	GIT_REBASE_INTERACTIVE = 3,
+	GIT_REBASE_INTERACTIVE = 3
 } git_rebase_t;
 
 struct git_rebase {
@@ -63,10 +65,10 @@ struct git_rebase {
 	git_rebase_t type;
 	char *state_path;
 
-	int head_detached : 1,
-		inmemory : 1,
-		quiet : 1,
-		started : 1;
+	unsigned int head_detached:1,
+	             inmemory:1,
+	             quiet:1,
+	             started:1;
 
 	git_array_t(git_rebase_operation) operations;
 	size_t current;
@@ -90,23 +92,31 @@ static int rebase_state_type(
 	char **path_out,
 	git_repository *repo)
 {
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
+	git_str interactive_path = GIT_STR_INIT;
 	git_rebase_t type = GIT_REBASE_NONE;
 
-	if (git_buf_joinpath(&path, repo->gitdir, REBASE_APPLY_DIR) < 0)
+	if (git_str_joinpath(&path, repo->gitdir, REBASE_APPLY_DIR) < 0)
 		return -1;
 
-	if (git_path_isdir(git_buf_cstr(&path))) {
+	if (git_fs_path_isdir(git_str_cstr(&path))) {
 		type = GIT_REBASE_APPLY;
 		goto done;
 	}
 
-	git_buf_clear(&path);
-	if (git_buf_joinpath(&path, repo->gitdir, REBASE_MERGE_DIR) < 0)
+	git_str_clear(&path);
+	if (git_str_joinpath(&path, repo->gitdir, REBASE_MERGE_DIR) < 0)
 		return -1;
 
-	if (git_path_isdir(git_buf_cstr(&path))) {
-		type = GIT_REBASE_MERGE;
+	if (git_fs_path_isdir(git_str_cstr(&path))) {
+		if (git_str_joinpath(&interactive_path, path.ptr, INTERACTIVE_FILE) < 0)
+			return -1;
+
+		if (git_fs_path_isfile(interactive_path.ptr))
+			type = GIT_REBASE_INTERACTIVE;
+		else
+			type = GIT_REBASE_MERGE;
+
 		goto done;
 	}
 
@@ -114,36 +124,37 @@ done:
 	*type_out = type;
 
 	if (type != GIT_REBASE_NONE && path_out)
-		*path_out = git_buf_detach(&path);
+		*path_out = git_str_detach(&path);
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
+	git_str_dispose(&interactive_path);
 
 	return 0;
 }
 
 GIT_INLINE(int) rebase_readfile(
-	git_buf *out,
-	git_buf *state_path,
+	git_str *out,
+	git_str *state_path,
 	const char *filename)
 {
 	size_t state_path_len = state_path->size;
 	int error;
 
-	git_buf_clear(out);
+	git_str_clear(out);
 
-	if ((error = git_buf_joinpath(state_path, state_path->ptr, filename)) < 0 ||
+	if ((error = git_str_joinpath(state_path, state_path->ptr, filename)) < 0 ||
 		(error = git_futils_readbuffer(out, state_path->ptr)) < 0)
 		goto done;
 
-	git_buf_rtrim(out);
+	git_str_rtrim(out);
 
 done:
-	git_buf_truncate(state_path, state_path_len);
+	git_str_truncate(state_path, state_path_len);
 	return error;
 }
 
 GIT_INLINE(int) rebase_readint(
-	size_t *out, git_buf *asc_out, git_buf *state_path, const char *filename)
+	size_t *out, git_str *asc_out, git_str *state_path, const char *filename)
 {
 	int32_t num;
 	const char *eol;
@@ -163,14 +174,15 @@ GIT_INLINE(int) rebase_readint(
 }
 
 GIT_INLINE(int) rebase_readoid(
-	git_oid *out, git_buf *str_out, git_buf *state_path, const char *filename)
+	git_oid *out, git_str *str_out, git_str *state_path, const char *filename)
 {
 	int error;
 
 	if ((error = rebase_readfile(str_out, state_path, filename)) < 0)
 		return error;
 
-	if (str_out->size != GIT_OID_HEXSZ || git_oid_fromstr(out, str_out->ptr) < 0) {
+	if (str_out->size != GIT_OID_SHA1_HEXSIZE ||
+	    git_oid__fromstr(out, str_out->ptr, GIT_OID_SHA1) < 0) {
 		git_error_set(GIT_ERROR_REBASE, "the file '%s' contains an invalid object ID", filename);
 		return -1;
 	}
@@ -201,13 +213,13 @@ static git_rebase_operation *rebase_operation_alloc(
 
 static int rebase_open_merge(git_rebase *rebase)
 {
-	git_buf state_path = GIT_BUF_INIT, buf = GIT_BUF_INIT, cmt = GIT_BUF_INIT;
+	git_str state_path = GIT_STR_INIT, buf = GIT_STR_INIT, cmt = GIT_STR_INIT;
 	git_oid id;
 	git_rebase_operation *operation;
 	size_t i, msgnum = 0, end;
 	int error;
 
-	if ((error = git_buf_puts(&state_path, rebase->state_path)) < 0)
+	if ((error = git_str_puts(&state_path, rebase->state_path)) < 0)
 		goto done;
 
 	/* Read 'msgnum' if it exists (otherwise, let msgnum = 0) */
@@ -234,9 +246,9 @@ static int rebase_open_merge(git_rebase *rebase)
 	GIT_ERROR_CHECK_ARRAY(rebase->operations);
 
 	for (i = 0; i < end; i++) {
-		git_buf_clear(&cmt);
+		git_str_clear(&cmt);
 
-		if ((error = git_buf_printf(&cmt, "cmt.%" PRIuZ, (i+1))) < 0 ||
+		if ((error = git_str_printf(&cmt, "cmt.%" PRIuZ, (i+1))) < 0 ||
 			(error = rebase_readoid(&id, &buf, &state_path, cmt.ptr)) < 0)
 			goto done;
 
@@ -248,12 +260,12 @@ static int rebase_open_merge(git_rebase *rebase)
 	if ((error = rebase_readfile(&buf, &state_path, ONTO_NAME_FILE)) < 0)
 		goto done;
 
-	rebase->onto_name = git_buf_detach(&buf);
+	rebase->onto_name = git_str_detach(&buf);
 
 done:
-	git_buf_dispose(&cmt);
-	git_buf_dispose(&state_path);
-	git_buf_dispose(&buf);
+	git_str_dispose(&cmt);
+	git_str_dispose(&state_path);
+	git_str_dispose(&buf);
 
 	return error;
 }
@@ -296,8 +308,8 @@ int git_rebase_open(
 	const git_rebase_options *given_opts)
 {
 	git_rebase *rebase;
-	git_buf path = GIT_BUF_INIT, orig_head_name = GIT_BUF_INIT,
-		orig_head_id = GIT_BUF_INIT, onto_id = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT, orig_head_name = GIT_STR_INIT,
+		orig_head_id = GIT_STR_INIT, onto_id = GIT_STR_INIT;
 	size_t state_path_len;
 	int error;
 
@@ -320,54 +332,54 @@ int git_rebase_open(
 		goto done;
 	}
 
-	if ((error = git_buf_puts(&path, rebase->state_path)) < 0)
+	if ((error = git_str_puts(&path, rebase->state_path)) < 0)
 		goto done;
 
-	state_path_len = git_buf_len(&path);
+	state_path_len = git_str_len(&path);
 
-	if ((error = git_buf_joinpath(&path, path.ptr, HEAD_NAME_FILE)) < 0 ||
+	if ((error = git_str_joinpath(&path, path.ptr, HEAD_NAME_FILE)) < 0 ||
 		(error = git_futils_readbuffer(&orig_head_name, path.ptr)) < 0)
 		goto done;
 
-	git_buf_rtrim(&orig_head_name);
+	git_str_rtrim(&orig_head_name);
 
 	if (strcmp(ORIG_DETACHED_HEAD, orig_head_name.ptr) == 0)
 		rebase->head_detached = 1;
 
-	git_buf_truncate(&path, state_path_len);
+	git_str_truncate(&path, state_path_len);
 
-	if ((error = git_buf_joinpath(&path, path.ptr, ORIG_HEAD_FILE)) < 0)
+	if ((error = git_str_joinpath(&path, path.ptr, ORIG_HEAD_FILE)) < 0)
 		goto done;
 
-	if (!git_path_isfile(path.ptr)) {
+	if (!git_fs_path_isfile(path.ptr)) {
 		/* Previous versions of git.git used 'head' here; support that. */
-		git_buf_truncate(&path, state_path_len);
+		git_str_truncate(&path, state_path_len);
 
-		if ((error = git_buf_joinpath(&path, path.ptr, HEAD_FILE)) < 0)
+		if ((error = git_str_joinpath(&path, path.ptr, HEAD_FILE)) < 0)
 			goto done;
 	}
 
 	if ((error = git_futils_readbuffer(&orig_head_id, path.ptr)) < 0)
 		goto done;
 
-	git_buf_rtrim(&orig_head_id);
+	git_str_rtrim(&orig_head_id);
 
-	if ((error = git_oid_fromstr(&rebase->orig_head_id, orig_head_id.ptr)) < 0)
+	if ((error = git_oid__fromstr(&rebase->orig_head_id, orig_head_id.ptr, GIT_OID_SHA1)) < 0)
 		goto done;
 
-	git_buf_truncate(&path, state_path_len);
+	git_str_truncate(&path, state_path_len);
 
-	if ((error = git_buf_joinpath(&path, path.ptr, ONTO_FILE)) < 0 ||
+	if ((error = git_str_joinpath(&path, path.ptr, ONTO_FILE)) < 0 ||
 		(error = git_futils_readbuffer(&onto_id, path.ptr)) < 0)
 		goto done;
 
-	git_buf_rtrim(&onto_id);
+	git_str_rtrim(&onto_id);
 
-	if ((error = git_oid_fromstr(&rebase->onto_id, onto_id.ptr)) < 0)
+	if ((error = git_oid__fromstr(&rebase->onto_id, onto_id.ptr, GIT_OID_SHA1)) < 0)
 		goto done;
 
 	if (!rebase->head_detached)
-		rebase->orig_head_name = git_buf_detach(&orig_head_name);
+		rebase->orig_head_name = git_str_detach(&orig_head_name);
 
 	switch (rebase->type) {
 	case GIT_REBASE_INTERACTIVE:
@@ -391,10 +403,10 @@ done:
 	else
 		git_rebase_free(rebase);
 
-	git_buf_dispose(&path);
-	git_buf_dispose(&orig_head_name);
-	git_buf_dispose(&orig_head_id);
-	git_buf_dispose(&onto_id);
+	git_str_dispose(&path);
+	git_str_dispose(&orig_head_name);
+	git_str_dispose(&orig_head_id);
+	git_str_dispose(&onto_id);
 	return error;
 }
 
@@ -403,27 +415,27 @@ static int rebase_cleanup(git_rebase *rebase)
 	if (!rebase || rebase->inmemory)
 		return 0;
 
-	return git_path_isdir(rebase->state_path) ?
+	return git_fs_path_isdir(rebase->state_path) ?
 		git_futils_rmdir_r(rebase->state_path, NULL, GIT_RMDIR_REMOVE_FILES) :
 		0;
 }
 
 static int rebase_setupfile(git_rebase *rebase, const char *filename, int flags, const char *fmt, ...)
 {
-	git_buf path = GIT_BUF_INIT,
-		contents = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT,
+		contents = GIT_STR_INIT;
 	va_list ap;
 	int error;
 
 	va_start(ap, fmt);
-	git_buf_vprintf(&contents, fmt, ap);
+	git_str_vprintf(&contents, fmt, ap);
 	va_end(ap);
 
-	if ((error = git_buf_joinpath(&path, rebase->state_path, filename)) == 0)
+	if ((error = git_str_joinpath(&path, rebase->state_path, filename)) == 0)
 		error = git_futils_writebuffer(&contents, path.ptr, flags, REBASE_FILE_MODE);
 
-	git_buf_dispose(&path);
-	git_buf_dispose(&contents);
+	git_str_dispose(&path);
+	git_str_dispose(&contents);
 
 	return error;
 }
@@ -440,8 +452,8 @@ static const char *rebase_onto_name(const git_annotated_commit *onto)
 
 static int rebase_setupfiles_merge(git_rebase *rebase)
 {
-	git_buf commit_filename = GIT_BUF_INIT;
-	char id_str[GIT_OID_HEXSZ];
+	git_str commit_filename = GIT_STR_INIT;
+	char id_str[GIT_OID_SHA1_HEXSIZE];
 	git_rebase_operation *operation;
 	size_t i;
 	int error = 0;
@@ -453,24 +465,24 @@ static int rebase_setupfiles_merge(git_rebase *rebase)
 	for (i = 0; i < git_array_size(rebase->operations); i++) {
 		operation = git_array_get(rebase->operations, i);
 
-		git_buf_clear(&commit_filename);
-		git_buf_printf(&commit_filename, CMT_FILE_FMT, i+1);
+		git_str_clear(&commit_filename);
+		git_str_printf(&commit_filename, CMT_FILE_FMT, i+1);
 
 		git_oid_fmt(id_str, &operation->id);
 
 		if ((error = rebase_setupfile(rebase, commit_filename.ptr, 0,
-				"%.*s\n", GIT_OID_HEXSZ, id_str)) < 0)
+				"%.*s\n", GIT_OID_SHA1_HEXSIZE, id_str)) < 0)
 			goto done;
 	}
 
 done:
-	git_buf_dispose(&commit_filename);
+	git_str_dispose(&commit_filename);
 	return error;
 }
 
 static int rebase_setupfiles(git_rebase *rebase)
 {
-	char onto[GIT_OID_HEXSZ], orig_head[GIT_OID_HEXSZ];
+	char onto[GIT_OID_SHA1_HEXSIZE], orig_head[GIT_OID_SHA1_HEXSIZE];
 	const char *orig_head_name;
 
 	git_oid_fmt(onto, &rebase->onto_id);
@@ -486,8 +498,8 @@ static int rebase_setupfiles(git_rebase *rebase)
 
 	if (git_repository__set_orig_head(rebase->repo, &rebase->orig_head_id) < 0 ||
 		rebase_setupfile(rebase, HEAD_NAME_FILE, 0, "%s\n", orig_head_name) < 0 ||
-		rebase_setupfile(rebase, ONTO_FILE, 0, "%.*s\n", GIT_OID_HEXSZ, onto) < 0 ||
-		rebase_setupfile(rebase, ORIG_HEAD_FILE, 0, "%.*s\n", GIT_OID_HEXSZ, orig_head) < 0 ||
+		rebase_setupfile(rebase, ONTO_FILE, 0, "%.*s\n", GIT_OID_SHA1_HEXSIZE, onto) < 0 ||
+		rebase_setupfile(rebase, ORIG_HEAD_FILE, 0, "%.*s\n", GIT_OID_SHA1_HEXSIZE, orig_head) < 0 ||
 		rebase_setupfile(rebase, QUIET_FILE, 0, rebase->quiet ? "t\n" : "\n") < 0)
 		return -1;
 
@@ -626,16 +638,16 @@ static int rebase_init_merge(
 {
 	git_reference *head_ref = NULL;
 	git_commit *onto_commit = NULL;
-	git_buf reflog = GIT_BUF_INIT;
-	git_buf state_path = GIT_BUF_INIT;
+	git_str reflog = GIT_STR_INIT;
+	git_str state_path = GIT_STR_INIT;
 	int error;
 
 	GIT_UNUSED(upstream);
 
-	if ((error = git_buf_joinpath(&state_path, repo->gitdir, REBASE_MERGE_DIR)) < 0)
+	if ((error = git_str_joinpath(&state_path, repo->gitdir, REBASE_MERGE_DIR)) < 0)
 		goto done;
 
-	rebase->state_path = git_buf_detach(&state_path);
+	rebase->state_path = git_str_detach(&state_path);
 	GIT_ERROR_CHECK_ALLOC(rebase->state_path);
 
 	if (branch->ref_name && strcmp(branch->ref_name, "HEAD")) {
@@ -654,7 +666,7 @@ static int rebase_init_merge(
 	git_oid_cpy(&rebase->onto_id, git_annotated_commit_id(onto));
 
 	if ((error = rebase_setupfiles(rebase)) < 0 ||
-		(error = git_buf_printf(&reflog,
+		(error = git_str_printf(&reflog,
 			"rebase: checkout %s", rebase_onto_name(onto))) < 0 ||
 		(error = git_commit_lookup(
 			&onto_commit, repo, git_annotated_commit_id(onto))) < 0 ||
@@ -667,8 +679,8 @@ static int rebase_init_merge(
 done:
 	git_reference_free(head_ref);
 	git_commit_free(onto_commit);
-	git_buf_dispose(&reflog);
-	git_buf_dispose(&state_path);
+	git_str_dispose(&reflog);
+	git_str_dispose(&state_path);
 
 	return error;
 }
@@ -795,14 +807,14 @@ static int rebase_next_merge(
 	git_rebase_operation **out,
 	git_rebase *rebase)
 {
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	git_commit *current_commit = NULL, *parent_commit = NULL;
 	git_tree *current_tree = NULL, *head_tree = NULL, *parent_tree = NULL;
 	git_index *index = NULL;
 	git_indexwriter indexwriter = GIT_INDEXWRITER_INIT;
 	git_rebase_operation *operation;
 	git_checkout_options checkout_opts;
-	char current_idstr[GIT_OID_HEXSZ];
+	char current_idstr[GIT_OID_SHA1_HEXSIZE];
 	unsigned int parent_count;
 	int error;
 
@@ -831,7 +843,7 @@ static int rebase_next_merge(
 
 	if ((error = git_indexwriter_init_for_operation(&indexwriter, rebase->repo, &checkout_opts.checkout_strategy)) < 0 ||
 		(error = rebase_setupfile(rebase, MSGNUM_FILE, 0, "%" PRIuZ "\n", rebase->current+1)) < 0 ||
-		(error = rebase_setupfile(rebase, CURRENT_FILE, 0, "%.*s\n", GIT_OID_HEXSZ, current_idstr)) < 0 ||
+		(error = rebase_setupfile(rebase, CURRENT_FILE, 0, "%.*s\n", GIT_OID_SHA1_HEXSIZE, current_idstr)) < 0 ||
 		(error = git_merge_trees(&index, rebase->repo, parent_tree, head_tree, current_tree, &rebase->options.merge_options)) < 0 ||
 		(error = git_merge__check_result(rebase->repo, index)) < 0 ||
 		(error = git_checkout_index(rebase->repo, index, &checkout_opts)) < 0 ||
@@ -848,7 +860,7 @@ done:
 	git_tree_free(parent_tree);
 	git_commit_free(parent_commit);
 	git_commit_free(current_commit);
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 
 	return error;
 }
@@ -955,14 +967,14 @@ static int create_signed(
 	size_t parent_count,
 	const git_commit **parents)
 {
-	git_buf commit_content = GIT_BUF_INIT,
-	        commit_signature = GIT_BUF_INIT,
-	        signature_field = GIT_BUF_INIT;
+	git_str commit_content = GIT_STR_INIT;
+	git_buf commit_signature = { NULL, 0, 0 },
+	        signature_field = { NULL, 0, 0 };
 	int error;
 
 	git_error_clear();
 
-	if ((error = git_commit_create_buffer(&commit_content,
+	if ((error = git_commit__create_buffer(&commit_content,
 		rebase->repo, author, committer, message_encoding,
 		message, tree, parent_count, parents)) < 0)
 		goto done;
@@ -986,7 +998,7 @@ static int create_signed(
 done:
 	git_buf_dispose(&commit_signature);
 	git_buf_dispose(&signature_field);
-	git_buf_dispose(&commit_content);
+	git_str_dispose(&commit_content);
 	return error;
 }
 #endif
@@ -1091,7 +1103,7 @@ static int rebase_commit_merge(
 	git_reference *head = NULL;
 	git_commit *head_commit = NULL, *commit = NULL;
 	git_index *index = NULL;
-	char old_idstr[GIT_OID_HEXSZ], new_idstr[GIT_OID_HEXSZ];
+	char old_idstr[GIT_OID_SHA1_HEXSIZE], new_idstr[GIT_OID_SHA1_HEXSIZE];
 	int error;
 
 	operation = git_array_get(rebase->operations, rebase->current);
@@ -1111,7 +1123,7 @@ static int rebase_commit_merge(
 	git_oid_fmt(new_idstr, git_commit_id(commit));
 
 	if ((error = rebase_setupfile(rebase, REWRITTEN_FILE, O_CREAT|O_WRONLY|O_APPEND,
-		"%.*s %.*s\n", GIT_OID_HEXSZ, old_idstr, GIT_OID_HEXSZ, new_idstr)) < 0)
+		"%.*s %.*s\n", GIT_OID_SHA1_HEXSIZE, old_idstr, GIT_OID_SHA1_HEXSIZE, new_idstr)) < 0)
 		goto done;
 
 	git_oid_cpy(commit_id, git_commit_id(commit));
@@ -1216,13 +1228,13 @@ done:
 	return error;
 }
 
-static int notes_ref_lookup(git_buf *out, git_rebase *rebase)
+static int notes_ref_lookup(git_str *out, git_rebase *rebase)
 {
 	git_config *config = NULL;
 	int do_rewrite, error;
 
 	if (rebase->options.rewrite_notes_ref) {
-		git_buf_attach_notowned(out,
+		git_str_attach_notowned(out,
 			rebase->options.rewrite_notes_ref,
 			strlen(rebase->options.rewrite_notes_ref));
 		return 0;
@@ -1239,7 +1251,7 @@ static int notes_ref_lookup(git_buf *out, git_rebase *rebase)
 	}
 
 	error = do_rewrite ?
-		git_config_get_string_buf(out, config, "notes.rewriteref") :
+		git_config__get_string_buf(out, config, "notes.rewriteref") :
 		GIT_ENOTFOUND;
 
 done:
@@ -1294,7 +1306,7 @@ static int rebase_copy_notes(
 	git_rebase *rebase,
 	const git_signature *committer)
 {
-	git_buf path = GIT_BUF_INIT, rewritten = GIT_BUF_INIT, notes_ref = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT, rewritten = GIT_STR_INIT, notes_ref = GIT_STR_INIT;
 	char *pair_list, *fromstr, *tostr, *end;
 	git_oid from, to;
 	unsigned int linenum = 1;
@@ -1309,7 +1321,7 @@ static int rebase_copy_notes(
 		goto done;
 	}
 
-	if ((error = git_buf_joinpath(&path, rebase->state_path, REWRITTEN_FILE)) < 0 ||
+	if ((error = git_str_joinpath(&path, rebase->state_path, REWRITTEN_FILE)) < 0 ||
 		(error = git_futils_readbuffer(&rewritten, path.ptr)) < 0)
 		goto done;
 
@@ -1330,10 +1342,10 @@ static int rebase_copy_notes(
 		tostr = end+1;
 		*end = '\0';
 
-		if (strlen(fromstr) != GIT_OID_HEXSZ ||
-			strlen(tostr) != GIT_OID_HEXSZ ||
-			git_oid_fromstr(&from, fromstr) < 0 ||
-			git_oid_fromstr(&to, tostr) < 0)
+		if (strlen(fromstr) != GIT_OID_SHA1_HEXSIZE ||
+			strlen(tostr) != GIT_OID_SHA1_HEXSIZE ||
+			git_oid__fromstr(&from, fromstr, GIT_OID_SHA1) < 0 ||
+			git_oid__fromstr(&to, tostr, GIT_OID_SHA1) < 0)
 			goto on_error;
 
 		if ((error = rebase_copy_note(rebase, notes_ref.ptr, &from, &to, committer)) < 0)
@@ -1349,9 +1361,9 @@ on_error:
 	error = -1;
 
 done:
-	git_buf_dispose(&rewritten);
-	git_buf_dispose(&path);
-	git_buf_dispose(&notes_ref);
+	git_str_dispose(&rewritten);
+	git_str_dispose(&path);
+	git_str_dispose(&notes_ref);
 
 	return error;
 }
@@ -1360,16 +1372,16 @@ static int return_to_orig_head(git_rebase *rebase)
 {
 	git_reference *terminal_ref = NULL, *branch_ref = NULL, *head_ref = NULL;
 	git_commit *terminal_commit = NULL;
-	git_buf branch_msg = GIT_BUF_INIT, head_msg = GIT_BUF_INIT;
-	char onto[GIT_OID_HEXSZ];
+	git_str branch_msg = GIT_STR_INIT, head_msg = GIT_STR_INIT;
+	char onto[GIT_OID_SHA1_HEXSIZE];
 	int error = 0;
 
 	git_oid_fmt(onto, &rebase->onto_id);
 
-	if ((error = git_buf_printf(&branch_msg,
+	if ((error = git_str_printf(&branch_msg,
 			"rebase finished: %s onto %.*s",
-			rebase->orig_head_name, GIT_OID_HEXSZ, onto)) == 0 &&
-		(error = git_buf_printf(&head_msg,
+			rebase->orig_head_name, GIT_OID_SHA1_HEXSIZE, onto)) == 0 &&
+		(error = git_str_printf(&head_msg,
 			"rebase finished: returning to %s",
 			rebase->orig_head_name)) == 0 &&
 		(error = git_repository_head(&terminal_ref, rebase->repo)) == 0 &&
@@ -1383,8 +1395,8 @@ static int return_to_orig_head(git_rebase *rebase)
 			rebase->repo, GIT_HEAD_FILE, rebase->orig_head_name, 1,
 			head_msg.ptr);
 
-	git_buf_dispose(&head_msg);
-	git_buf_dispose(&branch_msg);
+	git_str_dispose(&head_msg);
+	git_str_dispose(&branch_msg);
 	git_commit_free(terminal_commit);
 	git_reference_free(head_ref);
 	git_reference_free(branch_ref);