rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/posix.h

@@ -11,6 +11,7 @@
 
 #include <fcntl.h>
 #include <time.h>
+#include "fnmatch.h"
 
 /* stat: file mode type testing macros */
 #ifndef S_IFGITLINK
@@ -89,18 +90,6 @@
 #define EAFNOSUPPORT (INT_MAX-1)
 #endif
 
-/* Provide a 64-bit size for offsets. */
-
-#if defined(_MSC_VER)
-typedef __int64 off64_t;
-#elif defined(__HAIKU__)
-typedef __haiku_std_int64 off64_t;
-#elif defined(__APPLE__)
-typedef __int64_t off64_t;
-#else
-typedef int64_t off64_t;
-#endif
-
 typedef int git_file;
 
 /**

data/vendor/libgit2/src/proxy.c

@@ -9,29 +9,24 @@
 
 #include "git2/proxy.h"
 
-int git_proxy_options_init(git_proxy_options *opts, unsigned int version)
+int git_proxy_init_options(git_proxy_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_proxy_options, GIT_PROXY_OPTIONS_INIT);
 	return 0;
 }
 
-int git_proxy_init_options(git_proxy_options *opts, unsigned int version)
-{
-	return git_proxy_options_init(opts, version);
-}
-
 int git_proxy_options_dup(git_proxy_options *tgt, const git_proxy_options *src)
 {
 	if (!src) {
-		git_proxy_options_init(tgt, GIT_PROXY_OPTIONS_VERSION);
+		git_proxy_init_options(tgt, GIT_PROXY_OPTIONS_VERSION);
 		return 0;
 	}
 
 	memcpy(tgt, src, sizeof(git_proxy_options));
 	if (src->url) {
 		tgt->url = git__strdup(src->url);
-		GIT_ERROR_CHECK_ALLOC(tgt->url);
+		GITERR_CHECK_ALLOC(tgt->url);
 	}
 
 	return 0;

data/vendor/libgit2/src/push.c

@@ -36,7 +36,7 @@ int git_push_new(git_push **out, git_remote *remote)
 	*out = NULL;
 
 	p = git__calloc(1, sizeof(*p));
-	GIT_ERROR_CHECK_ALLOC(p);
+	GITERR_CHECK_ALLOC(p);
 
 	p->repo = remote->repo;
 	p->remote = remote;
@@ -70,11 +70,10 @@ int git_push_set_options(git_push *push, const git_push_options *opts)
 	if (!push || !opts)
 		return -1;
 
-	GIT_ERROR_CHECK_VERSION(opts, GIT_PUSH_OPTIONS_VERSION, "git_push_options");
+	GITERR_CHECK_VERSION(opts, GIT_PUSH_OPTIONS_VERSION, "git_push_options");
 
 	push->pb_parallelism = opts->pb_parallelism;
-	push->connection.custom_headers = &opts->custom_headers;
-	push->connection.proxy = &opts->proxy_opts;
+	push->custom_headers = &opts->custom_headers;
 
 	return 0;
 }
@@ -84,14 +83,14 @@ static void free_refspec(push_spec *spec)
 	if (spec == NULL)
 		return;
 
-	git_refspec__dispose(&spec->refspec);
+	git_refspec__free(&spec->refspec);
 	git__free(spec);
 }
 
 static int check_rref(char *ref)
 {
 	if (git__prefixcmp(ref, "refs/")) {
-		git_error_set(GIT_ERROR_INVALID, "not a valid reference '%s'", ref);
+		giterr_set(GITERR_INVALID, "not a valid reference '%s'", ref);
 		return -1;
 	}
 
@@ -109,10 +108,10 @@ static int check_lref(git_push *push, char *ref)
 		return 0;
 
 	if (error == GIT_ENOTFOUND)
-		git_error_set(GIT_ERROR_REFERENCE,
+		giterr_set(GITERR_REFERENCE,
 			"src refspec '%s' does not match any existing object", ref);
 	else
-		git_error_set(GIT_ERROR_INVALID, "not a valid reference '%s'", ref);
+		giterr_set(GITERR_INVALID, "not a valid reference '%s'", ref);
 	return -1;
 }
 
@@ -123,10 +122,10 @@ static int parse_refspec(git_push *push, push_spec **spec, const char *str)
 	*spec = NULL;
 
 	s = git__calloc(1, sizeof(*s));
-	GIT_ERROR_CHECK_ALLOC(s);
+	GITERR_CHECK_ALLOC(s);
 
 	if (git_refspec__parse(&s->refspec, str, false) < 0) {
-		git_error_set(GIT_ERROR_INVALID, "invalid refspec %s", str);
+		giterr_set(GITERR_INVALID, "invalid refspec %s", str);
 		goto on_error;
 	}
 
@@ -196,7 +195,7 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 			continue;
 
 		/* Update the remote ref */
-		if (git_oid_is_zero(&push_spec->loid)) {
+		if (git_oid_iszero(&push_spec->loid)) {
 			error = git_reference_lookup(&remote_ref, push->remote->repo, git_buf_cstr(&remote_ref_name));
 
 			if (error >= 0) {
@@ -213,7 +212,7 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 			if (error != GIT_ENOTFOUND)
 				goto on_error;
 
-			git_error_clear();
+			giterr_clear();
 			fire_callback = 0;
 		}
 
@@ -229,7 +228,7 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 	error = 0;
 
 on_error:
-	git_buf_dispose(&remote_ref_name);
+	git_buf_free(&remote_ref_name);
 	return error;
 }
 
@@ -242,10 +241,10 @@ static int enqueue_tag(git_object **out, git_push *push, git_oid *id)
 	git_object *obj = NULL, *target = NULL;
 	int error;
 
-	if ((error = git_object_lookup(&obj, push->repo, id, GIT_OBJECT_TAG)) < 0)
+	if ((error = git_object_lookup(&obj, push->repo, id, GIT_OBJ_TAG)) < 0)
 		return error;
 
-	while (git_object_type(obj) == GIT_OBJECT_TAG) {
+	while (git_object_type(obj) == GIT_OBJ_TAG) {
 		if ((error = git_packbuilder_insert(push->pb, git_object_id(obj), NULL)) < 0)
 			break;
 
@@ -278,10 +277,10 @@ static int queue_objects(git_push *push)
 	git_revwalk_sorting(rw, GIT_SORT_TIME);
 
 	git_vector_foreach(&push->specs, i, spec) {
-		git_object_t type;
+		git_otype type;
 		size_t size;
 
-		if (git_oid_is_zero(&spec->loid))
+		if (git_oid_iszero(&spec->loid))
 			/*
 			 * Delete reference on remote side;
 			 * nothing to do here.
@@ -294,13 +293,13 @@ static int queue_objects(git_push *push)
 		if (git_odb_read_header(&size, &type, push->repo->_odb, &spec->loid) < 0)
 			goto on_error;
 
-		if (type == GIT_OBJECT_TAG) {
+		if (type == GIT_OBJ_TAG) {
 			git_object *target;
 
 			if ((error = enqueue_tag(&target, push, &spec->loid)) < 0)
 				goto on_error;
 
-			if (git_object_type(target) == GIT_OBJECT_COMMIT) {
+			if (git_object_type(target) == GIT_OBJ_COMMIT) {
 				if (git_revwalk_push(rw, git_object_id(target)) < 0) {
 					git_object_free(target);
 					goto on_error;
@@ -319,11 +318,11 @@ static int queue_objects(git_push *push)
 		if (!spec->refspec.force) {
 			git_oid base;
 
-			if (git_oid_is_zero(&spec->roid))
+			if (git_oid_iszero(&spec->roid))
 				continue;
 
 			if (!git_odb_exists(push->repo->_odb, &spec->roid)) {
-				git_error_set(GIT_ERROR_REFERENCE,
+				giterr_set(GITERR_REFERENCE, 
 					"cannot push because a reference that you are trying to update on the remote contains commits that are not present locally.");
 				error = GIT_ENONFASTFORWARD;
 				goto on_error;
@@ -334,7 +333,7 @@ static int queue_objects(git_push *push)
 
 			if (error == GIT_ENOTFOUND ||
 				(!error && !git_oid_equal(&base, &spec->roid))) {
-				git_error_set(GIT_ERROR_REFERENCE,
+				giterr_set(GITERR_REFERENCE,
 					"cannot push non-fastforwardable reference");
 				error = GIT_ENONFASTFORWARD;
 				goto on_error;
@@ -346,7 +345,7 @@ static int queue_objects(git_push *push)
 	}
 
 	git_vector_foreach(&push->remote->refs, i, head) {
-		if (git_oid_is_zero(&head->oid))
+		if (git_oid_iszero(&head->oid))
 			continue;
 
 		/* TODO */
@@ -363,13 +362,13 @@ on_error:
 static int add_update(git_push *push, push_spec *spec)
 {
 	git_push_update *u = git__calloc(1, sizeof(git_push_update));
-	GIT_ERROR_CHECK_ALLOC(u);
+	GITERR_CHECK_ALLOC(u);
 
 	u->src_refname = git__strdup(spec->refspec.src);
-	GIT_ERROR_CHECK_ALLOC(u->src_refname);
+	GITERR_CHECK_ALLOC(u->src_refname);
 
 	u->dst_refname = git__strdup(spec->refspec.dst);
-	GIT_ERROR_CHECK_ALLOC(u->dst_refname);
+	GITERR_CHECK_ALLOC(u->dst_refname);
 
 	git_oid_cpy(&u->src, &spec->roid);
 	git_oid_cpy(&u->dst, &spec->loid);
@@ -390,7 +389,7 @@ static int calculate_work(git_push *push)
 			/* This is a create or update.  Local ref must exist. */
 			if (git_reference_name_to_id(
 					&spec->loid, push->repo, spec->refspec.src) < 0) {
-				git_error_set(GIT_ERROR_REFERENCE, "no such reference '%s'", spec->refspec.src);
+				giterr_set(GITERR_REFERENCE, "no such reference '%s'", spec->refspec.src);
 				return -1;
 			}
 		}
@@ -416,7 +415,7 @@ static int do_push(git_push *push, const git_remote_callbacks *callbacks)
 	git_transport *transport = push->remote->transport;
 
 	if (!transport->push) {
-		git_error_set(GIT_ERROR_NET, "remote transport doesn't support push");
+		giterr_set(GITERR_NET, "remote transport doesn't support push");
 		error = -1;
 		goto on_error;
 	}
@@ -476,7 +475,7 @@ int git_push_finish(git_push *push, const git_remote_callbacks *callbacks)
 	int error;
 
 	if (!git_remote_connected(push->remote) &&
-	    (error = git_remote__connect(push->remote, GIT_DIRECTION_PUSH, callbacks, &push->connection)) < 0)
+	    (error = git_remote_connect(push->remote, GIT_DIRECTION_PUSH, callbacks, NULL, push->custom_headers)) < 0)
 		return error;
 
 	if ((error = filter_refs(push->remote)) < 0 ||
@@ -485,7 +484,7 @@ int git_push_finish(git_push *push, const git_remote_callbacks *callbacks)
 
 	if (!push->unpack_ok) {
 		error = -1;
-		git_error_set(GIT_ERROR_NET, "unpacking the sent packfile failed on the remote");
+		giterr_set(GITERR_NET, "unpacking the sent packfile failed on the remote");
 	}
 
 	return error;
@@ -501,7 +500,7 @@ int git_push_status_foreach(git_push *push,
 	git_vector_foreach(&push->status, i, status) {
 		int error = cb(status->ref, status->msg, data);
 		if (error)
-			return git_error_set_after_callback(error);
+			return giterr_set_after_callback(error);
 	}
 
 	return 0;
@@ -547,14 +546,9 @@ void git_push_free(git_push *push)
 	git__free(push);
 }
 
-int git_push_options_init(git_push_options *opts, unsigned int version)
+int git_push_init_options(git_push_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_push_options, GIT_PUSH_OPTIONS_INIT);
 	return 0;
 }
-
-int git_push_init_options(git_push_options *opts, unsigned int version)
-{
-	return git_push_options_init(opts, version);
-}

data/vendor/libgit2/src/push.h

@@ -11,7 +11,6 @@
 
 #include "git2.h"
 #include "refspec.h"
-#include "remote.h"
 
 typedef struct push_spec {
 	struct git_refspec refspec;
@@ -41,7 +40,7 @@ struct git_push {
 
 	/* options */
 	unsigned pb_parallelism;
-	git_remote_connection_opts connection;
+	const git_strarray *custom_headers;
 };
 
 /**

data/vendor/libgit2/src/rebase.c

@@ -116,7 +116,7 @@ done:
 	if (type != GIT_REBASE_TYPE_NONE && path_out)
 		*path_out = git_buf_detach(&path);
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return 0;
 }
@@ -153,7 +153,7 @@ GIT_INLINE(int) rebase_readint(
 		return error;
 
 	if (git__strntol32(&num, asc_out->ptr, asc_out->size, &eol, 10) < 0 || num < 0 || *eol) {
-		git_error_set(GIT_ERROR_REBASE, "the file '%s' contains an invalid numeric value", filename);
+		giterr_set(GITERR_REBASE, "the file '%s' contains an invalid numeric value", filename);
 		return -1;
 	}
 
@@ -171,7 +171,7 @@ GIT_INLINE(int) rebase_readoid(
 		return error;
 
 	if (str_out->size != GIT_OID_HEXSZ || git_oid_fromstr(out, str_out->ptr) < 0) {
-		git_error_set(GIT_ERROR_REBASE, "the file '%s' contains an invalid object ID", filename);
+		giterr_set(GITERR_REBASE, "the file '%s' contains an invalid object ID", filename);
 		return -1;
 	}
 
@@ -231,7 +231,7 @@ static int rebase_open_merge(git_rebase *rebase)
 
 	/* Read cmt.* */
 	git_array_init_to_size(rebase->operations, end);
-	GIT_ERROR_CHECK_ARRAY(rebase->operations);
+	GITERR_CHECK_ARRAY(rebase->operations);
 
 	for (i = 0; i < end; i++) {
 		git_buf_clear(&cmt);
@@ -241,7 +241,7 @@ static int rebase_open_merge(git_rebase *rebase)
 			goto done;
 
 		operation = rebase_operation_alloc(rebase, GIT_REBASE_OPERATION_PICK, &id, NULL);
-		GIT_ERROR_CHECK_ALLOC(operation);
+		GITERR_CHECK_ALLOC(operation);
 	}
 
 	/* Read 'onto_name' */
@@ -251,9 +251,9 @@ static int rebase_open_merge(git_rebase *rebase)
 	rebase->onto_name = git_buf_detach(&buf);
 
 done:
-	git_buf_dispose(&cmt);
-	git_buf_dispose(&state_path);
-	git_buf_dispose(&buf);
+	git_buf_free(&cmt);
+	git_buf_free(&state_path);
+	git_buf_free(&buf);
 
 	return error;
 }
@@ -261,20 +261,23 @@ done:
 static int rebase_alloc(git_rebase **out, const git_rebase_options *rebase_opts)
 {
 	git_rebase *rebase = git__calloc(1, sizeof(git_rebase));
-	GIT_ERROR_CHECK_ALLOC(rebase);
+	GITERR_CHECK_ALLOC(rebase);
 
 	*out = NULL;
 
 	if (rebase_opts)
 		memcpy(&rebase->options, rebase_opts, sizeof(git_rebase_options));
 	else
-		git_rebase_options_init(&rebase->options, GIT_REBASE_OPTIONS_VERSION);
+		git_rebase_init_options(&rebase->options, GIT_REBASE_OPTIONS_VERSION);
 
 	if (rebase_opts && rebase_opts->rewrite_notes_ref) {
 		rebase->options.rewrite_notes_ref = git__strdup(rebase_opts->rewrite_notes_ref);
-		GIT_ERROR_CHECK_ALLOC(rebase->options.rewrite_notes_ref);
+		GITERR_CHECK_ALLOC(rebase->options.rewrite_notes_ref);
 	}
 
+	if ((rebase->options.checkout_options.checkout_strategy & (GIT_CHECKOUT_SAFE | GIT_CHECKOUT_FORCE)) == 0)
+		rebase->options.checkout_options.checkout_strategy = GIT_CHECKOUT_SAFE;
+
 	*out = rebase;
 
 	return 0;
@@ -282,10 +285,10 @@ static int rebase_alloc(git_rebase **out, const git_rebase_options *rebase_opts)
 
 static int rebase_check_versions(const git_rebase_options *given_opts)
 {
-	GIT_ERROR_CHECK_VERSION(given_opts, GIT_REBASE_OPTIONS_VERSION, "git_rebase_options");
+	GITERR_CHECK_VERSION(given_opts, GIT_REBASE_OPTIONS_VERSION, "git_rebase_options");
 
 	if (given_opts)
-		GIT_ERROR_CHECK_VERSION(&given_opts->checkout_options, GIT_CHECKOUT_OPTIONS_VERSION, "git_checkout_options");
+		GITERR_CHECK_VERSION(&given_opts->checkout_options, GIT_CHECKOUT_OPTIONS_VERSION, "git_checkout_options");
 
 	return 0;
 }
@@ -298,8 +301,7 @@ int git_rebase_open(
 	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;
-	size_t state_path_len;
-	int error;
+	int state_path_len, error;
 
 	assert(repo);
 
@@ -315,7 +317,7 @@ int git_rebase_open(
 		goto done;
 
 	if (rebase->type == GIT_REBASE_TYPE_NONE) {
-		git_error_set(GIT_ERROR_REBASE, "there is no rebase in progress");
+		giterr_set(GITERR_REBASE, "there is no rebase in progress");
 		error = GIT_ENOTFOUND;
 		goto done;
 	}
@@ -371,14 +373,14 @@ int git_rebase_open(
 
 	switch (rebase->type) {
 	case GIT_REBASE_TYPE_INTERACTIVE:
-		git_error_set(GIT_ERROR_REBASE, "interactive rebase is not supported");
+		giterr_set(GITERR_REBASE, "interactive rebase is not supported");
 		error = -1;
 		break;
 	case GIT_REBASE_TYPE_MERGE:
 		error = rebase_open_merge(rebase);
 		break;
 	case GIT_REBASE_TYPE_APPLY:
-		git_error_set(GIT_ERROR_REBASE, "patch application rebase is not supported");
+		giterr_set(GITERR_REBASE, "patch application rebase is not supported");
 		error = -1;
 		break;
 	default:
@@ -391,10 +393,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_buf_free(&path);
+	git_buf_free(&orig_head_name);
+	git_buf_free(&orig_head_id);
+	git_buf_free(&onto_id);
 	return error;
 }
 
@@ -422,8 +424,8 @@ static int rebase_setupfile(git_rebase *rebase, const char *filename, int flags,
 	if ((error = git_buf_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_buf_free(&path);
+	git_buf_free(&contents);
 
 	return error;
 }
@@ -464,7 +466,7 @@ static int rebase_setupfiles_merge(git_rebase *rebase)
 	}
 
 done:
-	git_buf_dispose(&commit_filename);
+	git_buf_free(&commit_filename);
 	return error;
 }
 
@@ -477,7 +479,7 @@ static int rebase_setupfiles(git_rebase *rebase)
 	git_oid_fmt(orig_head, &rebase->orig_head_id);
 
 	if (p_mkdir(rebase->state_path, REBASE_DIR_MODE) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to create rebase directory '%s'", rebase->state_path);
+		giterr_set(GITERR_OS, "failed to create rebase directory '%s'", rebase->state_path);
 		return -1;
 	}
 
@@ -494,18 +496,13 @@ static int rebase_setupfiles(git_rebase *rebase)
 	return rebase_setupfiles_merge(rebase);
 }
 
-int git_rebase_options_init(git_rebase_options *opts, unsigned int version)
+int git_rebase_init_options(git_rebase_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_rebase_options, GIT_REBASE_OPTIONS_INIT);
 	return 0;
 }
 
-int git_rebase_init_options(git_rebase_options *opts, unsigned int version)
-{
-	return git_rebase_options_init(opts, version);
-}
-
 static int rebase_ensure_not_in_progress(git_repository *repo)
 {
 	int error;
@@ -515,7 +512,7 @@ static int rebase_ensure_not_in_progress(git_repository *repo)
 		return error;
 
 	if (type != GIT_REBASE_TYPE_NONE) {
-		git_error_set(GIT_ERROR_REBASE, "there is an existing rebase in progress");
+		giterr_set(GITERR_REBASE, "there is an existing rebase in progress");
 		return -1;
 	}
 
@@ -540,7 +537,7 @@ static int rebase_ensure_not_dirty(
 			goto done;
 
 		if (git_diff_num_deltas(diff) > 0) {
-			git_error_set(GIT_ERROR_REBASE, "uncommitted changes exist in index");
+			giterr_set(GITERR_REBASE, "uncommitted changes exist in index");
 			error = fail_with;
 			goto done;
 		}
@@ -556,7 +553,7 @@ static int rebase_ensure_not_dirty(
 			goto done;
 
 		if (git_diff_num_deltas(diff) > 0) {
-			git_error_set(GIT_ERROR_REBASE, "unstaged changes exist in workdir");
+			giterr_set(GITERR_REBASE, "unstaged changes exist in workdir");
 			error = fail_with;
 			goto done;
 		}
@@ -605,7 +602,7 @@ static int rebase_init_operations(
 			continue;
 
 		operation = rebase_operation_alloc(rebase, GIT_REBASE_OPERATION_PICK, &id, NULL);
-		GIT_ERROR_CHECK_ALLOC(operation);
+		GITERR_CHECK_ALLOC(operation);
 	}
 
 	error = 0;
@@ -634,17 +631,17 @@ static int rebase_init_merge(
 		goto done;
 
 	rebase->state_path = git_buf_detach(&state_path);
-	GIT_ERROR_CHECK_ALLOC(rebase->state_path);
+	GITERR_CHECK_ALLOC(rebase->state_path);
 
 	if (branch->ref_name && strcmp(branch->ref_name, "HEAD")) {
 		rebase->orig_head_name = git__strdup(branch->ref_name);
-		GIT_ERROR_CHECK_ALLOC(rebase->orig_head_name);
+		GITERR_CHECK_ALLOC(rebase->orig_head_name);
 	} else {
 		rebase->head_detached = 1;
 	}
 
 	rebase->onto_name = git__strdup(rebase_onto_name(onto));
-	GIT_ERROR_CHECK_ALLOC(rebase->onto_name);
+	GITERR_CHECK_ALLOC(rebase->onto_name);
 
 	rebase->quiet = rebase->options.quiet;
 
@@ -665,8 +662,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_buf_free(&reflog);
+	git_buf_free(&state_path);
 
 	return error;
 }
@@ -813,7 +810,7 @@ static int rebase_next_merge(
 		goto done;
 
 	if ((parent_count = git_commit_parentcount(current_commit)) > 1) {
-		git_error_set(GIT_ERROR_REBASE, "cannot rebase a merge commit");
+		giterr_set(GITERR_REBASE, "cannot rebase a merge commit");
 		error = -1;
 		goto done;
 	} else if (parent_count) {
@@ -845,7 +842,7 @@ done:
 	git_tree_free(parent_tree);
 	git_commit_free(parent_commit);
 	git_commit_free(current_commit);
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
 }
@@ -870,7 +867,7 @@ static int rebase_next_inmemory(
 		goto done;
 
 	if ((parent_count = git_commit_parentcount(current_commit)) > 1) {
-		git_error_set(GIT_ERROR_REBASE, "cannot rebase a merge commit");
+		giterr_set(GITERR_REBASE, "cannot rebase a merge commit");
 		error = -1;
 		goto done;
 	} else if (parent_count) {
@@ -951,16 +948,12 @@ static int rebase_commit__create(
 	git_commit *current_commit = NULL, *commit = NULL;
 	git_tree *parent_tree = NULL, *tree = NULL;
 	git_oid tree_id, commit_id;
-	git_buf commit_content = GIT_BUF_INIT, commit_signature = GIT_BUF_INIT,
-		signature_field = GIT_BUF_INIT;
-	const char *signature_field_string = NULL,
-		*commit_signature_string = NULL;
 	int error;
 
 	operation = git_array_get(rebase->operations, rebase->current);
 
 	if (git_index_has_conflicts(index)) {
-		git_error_set(GIT_ERROR_REBASE, "conflicts have not been resolved");
+		giterr_set(GITERR_REBASE, "conflicts have not been resolved");
 		error = GIT_EUNMERGED;
 		goto done;
 	}
@@ -972,7 +965,7 @@ static int rebase_commit__create(
 		goto done;
 
 	if (git_oid_equal(&tree_id, git_tree_id(parent_tree))) {
-		git_error_set(GIT_ERROR_REBASE, "this patch has already been applied");
+		giterr_set(GITERR_REBASE, "this patch has already been applied");
 		error = GIT_EAPPLIED;
 		goto done;
 	}
@@ -985,40 +978,10 @@ static int rebase_commit__create(
 		message = git_commit_message(current_commit);
 	}
 
-	if ((error = git_commit_create_buffer(&commit_content, rebase->repo, author, committer,
-			message_encoding, message, tree, 1, (const git_commit **)&parent_commit)) < 0)
-		goto done;
-
-	if (rebase->options.signing_cb) {
-		git_error_clear();
-		error = git_error_set_after_callback_function(rebase->options.signing_cb(
-			&commit_signature, &signature_field, git_buf_cstr(&commit_content),
-			rebase->options.payload), "commit signing_cb failed");
-		if (error == GIT_PASSTHROUGH) {
-			git_buf_dispose(&commit_signature);
-			git_buf_dispose(&signature_field);
-			git_error_clear();
-			error = GIT_OK;
-		} else if (error < 0)
-			goto done;
-	}
-
-	if (git_buf_is_allocated(&commit_signature)) {
-		assert(git_buf_contains_nul(&commit_signature));
-		commit_signature_string = git_buf_cstr(&commit_signature);
-	}
-
-	if (git_buf_is_allocated(&signature_field)) {
-		assert(git_buf_contains_nul(&signature_field));
-		signature_field_string = git_buf_cstr(&signature_field);
-	}
-
-	if ((error = git_commit_create_with_signature(&commit_id, rebase->repo,
-			git_buf_cstr(&commit_content), commit_signature_string,
-			signature_field_string)))
-		goto done;
-
-	if ((error = git_commit_lookup(&commit, rebase->repo, &commit_id)) < 0)
+	if ((error = git_commit_create(&commit_id, rebase->repo, NULL, author,
+		committer, message_encoding, message, tree, 1,
+		(const git_commit **)&parent_commit)) < 0 ||
+		(error = git_commit_lookup(&commit, rebase->repo, &commit_id)) < 0)
 		goto done;
 
 	*out = commit;
@@ -1027,9 +990,6 @@ done:
 	if (error < 0)
 		git_commit_free(commit);
 
-	git_buf_dispose(&commit_signature);
-	git_buf_dispose(&signature_field);
-	git_buf_dispose(&commit_content);
 	git_commit_free(current_commit);
 	git_tree_free(parent_tree);
 	git_tree_free(tree);
@@ -1057,7 +1017,7 @@ static int rebase_commit_merge(
 
 	if ((error = rebase_ensure_not_dirty(rebase->repo, false, true, GIT_EUNMERGED)) < 0 ||
 		(error = git_repository_head(&head, rebase->repo)) < 0 ||
-		(error = git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT)) < 0 ||
+		(error = git_reference_peel((git_object **)&head_commit, head, GIT_OBJ_COMMIT)) < 0 ||
 		(error = git_repository_index(&index, rebase->repo)) < 0 ||
 		(error = rebase_commit__create(&commit, rebase, index, head_commit,
 			author, committer, message_encoding, message)) < 0 ||
@@ -1191,7 +1151,7 @@ static int notes_ref_lookup(git_buf *out, git_rebase *rebase)
 		if (error != GIT_ENOTFOUND)
 			goto done;
 
-		git_error_clear();
+		giterr_clear();
 		do_rewrite = 1;
 	}
 
@@ -1218,7 +1178,7 @@ static int rebase_copy_note(
 
 	if ((error = git_note_read(&note, rebase->repo, notes_ref, from)) < 0) {
 		if (error == GIT_ENOTFOUND) {
-			git_error_clear();
+			giterr_clear();
 			error = 0;
 		}
 
@@ -1231,7 +1191,7 @@ static int rebase_copy_note(
 				(error = git_signature_now(&who, "unknown", "unknown")) < 0)
 				goto done;
 
-			git_error_clear();
+			giterr_clear();
 		}
 
 		committer = who;
@@ -1259,7 +1219,7 @@ static int rebase_copy_notes(
 
 	if ((error = notes_ref_lookup(&notes_ref, rebase)) < 0) {
 		if (error == GIT_ENOTFOUND) {
-			git_error_clear();
+			giterr_clear();
 			error = 0;
 		}
 
@@ -1302,13 +1262,13 @@ static int rebase_copy_notes(
 	goto done;
 
 on_error:
-	git_error_set(GIT_ERROR_REBASE, "invalid rewritten file at line %d", linenum);
+	giterr_set(GITERR_REBASE, "invalid rewritten file at line %d", linenum);
 	error = -1;
 
 done:
-	git_buf_dispose(&rewritten);
-	git_buf_dispose(&path);
-	git_buf_dispose(&notes_ref);
+	git_buf_free(&rewritten);
+	git_buf_free(&path);
+	git_buf_free(&notes_ref);
 
 	return error;
 }
@@ -1331,7 +1291,7 @@ static int return_to_orig_head(git_rebase *rebase)
 			rebase->orig_head_name)) == 0 &&
 		(error = git_repository_head(&terminal_ref, rebase->repo)) == 0 &&
 		(error = git_reference_peel((git_object **)&terminal_commit,
-			terminal_ref, GIT_OBJECT_COMMIT)) == 0 &&
+			terminal_ref, GIT_OBJ_COMMIT)) == 0 &&
 		(error = git_reference_create_matching(&branch_ref,
 			rebase->repo, rebase->orig_head_name,
 			git_commit_id(terminal_commit), 1,
@@ -1340,8 +1300,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_buf_free(&head_msg);
+	git_buf_free(&branch_msg);
 	git_commit_free(terminal_commit);
 	git_reference_free(head_ref);
 	git_reference_free(branch_ref);
@@ -1370,22 +1330,6 @@ int git_rebase_finish(
 	return error;
 }
 
-const char *git_rebase_orig_head_name(git_rebase *rebase) {
-	return rebase->orig_head_name;
-}
-
-const git_oid *git_rebase_orig_head_id(git_rebase *rebase) {
-	return &rebase->orig_head_id;
-}
-
-const char *git_rebase_onto_name(git_rebase *rebase) {
-	return rebase->onto_name;
-}
-
-const git_oid *git_rebase_onto_id(git_rebase *rebase) {
-	return &rebase->onto_id;
-}
-
 size_t git_rebase_operation_entrycount(git_rebase *rebase)
 {
 	assert(rebase);