rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/delta.c

@@ -124,21 +124,21 @@ static int lookup_index_alloc(
 {
 	size_t entries_len, hash_len, index_len;
 
-	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&entries_len, entries, sizeof(struct index_entry));
-	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&hash_len, hash_count, sizeof(struct index_entry *));
+	GITERR_CHECK_ALLOC_MULTIPLY(&entries_len, entries, sizeof(struct index_entry));
+	GITERR_CHECK_ALLOC_MULTIPLY(&hash_len, hash_count, sizeof(struct index_entry *));
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&index_len, sizeof(struct git_delta_index), entries_len);
-	GIT_ERROR_CHECK_ALLOC_ADD(&index_len, index_len, hash_len);
+	GITERR_CHECK_ALLOC_ADD(&index_len, sizeof(struct git_delta_index), entries_len);
+	GITERR_CHECK_ALLOC_ADD(&index_len, index_len, hash_len);
 
 	if (!git__is_ulong(index_len)) {
-		git_error_set(GIT_ERROR_NOMEMORY, "overly large delta");
+		giterr_set(GITERR_NOMEMORY, "overly large delta");
 		return -1;
 	}
 
 	*out = git__malloc(index_len);
-	GIT_ERROR_CHECK_ALLOC(*out);
+	GITERR_CHECK_ALLOC(*out);
 
-	*out_len = (unsigned long)index_len;
+	*out_len = index_len;
 	return 0;
 }
 
@@ -286,22 +286,15 @@ int git_delta_create_from_index(
 	if (!trg_buf || !trg_size)
 		return 0;
 
-	if (index->src_size > UINT_MAX ||
-	    trg_size > UINT_MAX ||
-	    max_size > (UINT_MAX - MAX_OP_SIZE - 1)) {
-		git_error_set(GIT_ERROR_INVALID, "buffer sizes too large for delta processing");
-		return -1;
-	}
-
 	bufpos = 0;
 	bufsize = 8192;
 	if (max_size && bufsize >= max_size)
 		bufsize = (unsigned int)(max_size + MAX_OP_SIZE + 1);
 	buf = git__malloc(bufsize);
-	GIT_ERROR_CHECK_ALLOC(buf);
+	GITERR_CHECK_ALLOC(buf);
 
 	/* store reference buffer size */
-	i = (unsigned int)index->src_size;
+	i = index->src_size;
 	while (i >= 0x80) {
 		buf[bufpos++] = i | 0x80;
 		i >>= 7;
@@ -309,7 +302,7 @@ int git_delta_create_from_index(
 	buf[bufpos++] = i;
 
 	/* store target buffer size */
-	i = (unsigned int)trg_size;
+	i = trg_size;
 	while (i >= 0x80) {
 		buf[bufpos++] = i | 0x80;
 		i >>= 7;
@@ -430,7 +423,7 @@ int git_delta_create_from_index(
 			void *tmp = buf;
 			bufsize = bufsize * 3 / 2;
 			if (max_size && bufsize >= max_size)
-				bufsize = (unsigned int)(max_size + MAX_OP_SIZE + 1);
+				bufsize = max_size + MAX_OP_SIZE + 1;
 			if (max_size && bufpos > max_size)
 				break;
 			buf = git__realloc(buf, bufsize);
@@ -445,7 +438,7 @@ int git_delta_create_from_index(
 		buf[bufpos - inscnt - 1] = inscnt;
 
 	if (max_size && bufpos > max_size) {
-		git_error_set(GIT_ERROR_NOMEMORY, "delta would be larger than maximum size");
+		giterr_set(GITERR_NOMEMORY, "delta would be larger than maximum size");
 		git__free(buf);
 		return GIT_EBUFS;
 	}
@@ -473,7 +466,7 @@ static int hdr_sz(
 
 	do {
 		if (d == end) {
-			git_error_set(GIT_ERROR_INVALID, "truncated delta");
+			giterr_set(GITERR_INVALID, "truncated delta");
 			return -1;
 		}
 
@@ -552,18 +545,18 @@ int git_delta_apply(
 	 * base object, resulting in data corruption or segfault.
 	 */
 	if ((hdr_sz(&base_sz, &delta, delta_end) < 0) || (base_sz != base_len)) {
-		git_error_set(GIT_ERROR_INVALID, "failed to apply delta: base size does not match given data");
+		giterr_set(GITERR_INVALID, "failed to apply delta: base size does not match given data");
 		return -1;
 	}
 
 	if (hdr_sz(&res_sz, &delta, delta_end) < 0) {
-		git_error_set(GIT_ERROR_INVALID, "failed to apply delta: base size does not match given data");
+		giterr_set(GITERR_INVALID, "failed to apply delta: base size does not match given data");
 		return -1;
 	}
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_sz, res_sz, 1);
+	GITERR_CHECK_ALLOC_ADD(&alloc_sz, res_sz, 1);
 	res_dp = git__malloc(alloc_sz);
-	GIT_ERROR_CHECK_ALLOC(res_dp);
+	GITERR_CHECK_ALLOC(res_dp);
 
 	res_dp[res_sz] = '\0';
 	*out = res_dp;
@@ -623,6 +616,6 @@ fail:
 	*out = NULL;
 	*out_len = 0;
 
-	git_error_set(GIT_ERROR_INVALID, "failed to apply delta");
+	giterr_set(GITERR_INVALID, "failed to apply delta");
 	return -1;
 }

data/vendor/libgit2/src/describe.c

@@ -16,11 +16,10 @@
 #include "commit_list.h"
 #include "oidmap.h"
 #include "refs.h"
-#include "repository.h"
 #include "revwalk.h"
 #include "tag.h"
 #include "vector.h"
-#include "wildmatch.h"
+#include "repository.h"
 
 /* Ported from https://github.com/git/git/blob/89dde7882f71f846ccd0359756d27bebc31108de/builtin/describe.c */
 
@@ -37,7 +36,12 @@ struct commit_name {
 
 static void *oidmap_value_bykey(git_oidmap *map, const git_oid *key)
 {
-	return git_oidmap_get(map, key);
+	khint_t pos = git_oidmap_lookup_index(map, key);
+
+	if (!git_oidmap_valid_index(map, pos))
+		return NULL;
+
+	return git_oidmap_value_at(map, pos);
 }
 
 static struct commit_name *find_commit_name(
@@ -104,7 +108,7 @@ static int add_to_known_names(
 	if (replace_name(&tag, repo, e, prio, sha1)) {
 		if (!found) {
 			e = git__malloc(sizeof(struct commit_name));
-			GIT_ERROR_CHECK_ALLOC(e);
+			GITERR_CHECK_ALLOC(e);
 
 			e->path = NULL;
 			e->tag = NULL;
@@ -120,8 +124,13 @@ static int add_to_known_names(
 		e->path = git__strdup(path);
 		git_oid_cpy(&e->peeled, peeled);
 
-		if (!found && git_oidmap_set(names, &e->peeled, e) < 0)
-			return -1;
+		if (!found) {
+			int ret;
+
+			git_oidmap_insert(names, &e->peeled, e, &ret);
+			if (ret < 0)
+				return -1;
+		}
 	}
 	else
 		git_tag_free(tag);
@@ -142,7 +151,7 @@ static int retrieve_peeled_tag_or_object_oid(
 	if ((error = git_reference_lookup_resolved(&ref, repo, refname, -1)) < 0)
 		return error;
 
-	if ((error = git_reference_peel(&peeled, ref, GIT_OBJECT_ANY)) < 0)
+	if ((error = git_reference_peel(&peeled, ref, GIT_OBJ_ANY)) < 0)
 		goto cleanup;
 
 	git_oid_cpy(ref_target_out, git_reference_target(ref));
@@ -182,7 +191,7 @@ static int commit_name_dup(struct commit_name **out, struct commit_name *in)
 	struct commit_name *name;
 
 	name = git__malloc(sizeof(struct commit_name));
-	GIT_ERROR_CHECK_ALLOC(name);
+	GITERR_CHECK_ALLOC(name);
 
 	memcpy(name, in,  sizeof(struct commit_name));
 	name->tag = NULL;
@@ -192,7 +201,7 @@ static int commit_name_dup(struct commit_name **out, struct commit_name *in)
 		return -1;
 
 	name->path = git__strdup(in->path);
-	GIT_ERROR_CHECK_ALLOC(name->path);
+	GITERR_CHECK_ALLOC(name->path);
 
 	*out = name;
 	return 0;
@@ -215,7 +224,7 @@ static int get_name(const char *refname, void *payload)
 		return 0;
 
 	/* Accept only tags that match the pattern, if given */
-	if (data->opts->pattern && (!is_tag || wildmatch(data->opts->pattern,
+	if (data->opts->pattern && (!is_tag || p_fnmatch(data->opts->pattern,
 		refname + strlen(GIT_REFS_TAGS_DIR), 0)))
 				return 0;
 
@@ -258,7 +267,7 @@ static int possible_tag_dup(struct possible_tag **out, struct possible_tag *in)
 	int error;
 
 	tag = git__malloc(sizeof(struct possible_tag));
-	GIT_ERROR_CHECK_ALLOC(tag);
+	GITERR_CHECK_ALLOC(tag);
 
 	memcpy(tag, in, sizeof(struct possible_tag));
 	tag->name = NULL;
@@ -326,14 +335,14 @@ static int display_name(git_buf *buf, git_repository *repo, struct commit_name *
 {
 	if (n->prio == 2 && !n->tag) {
 		if (git_tag_lookup(&n->tag, repo, &n->sha1) < 0) {
-			git_error_set(GIT_ERROR_TAG, "annotated tag '%s' not available", n->path);
+			giterr_set(GITERR_TAG, "annotated tag '%s' not available", n->path);
 			return -1;
 		}
 	}
 
 	if (n->tag && !n->name_checked) {
 		if (!git_tag_name(n->tag)) {
-			git_error_set(GIT_ERROR_TAG, "annotated tag '%s' has no embedded name", n->path);
+			giterr_set(GITERR_TAG, "annotated tag '%s' has no embedded name", n->path);
 			return -1;
 		}
 
@@ -357,7 +366,7 @@ static int find_unique_abbrev_size(
 	int *out,
 	git_repository *repo,
 	const git_oid *oid_in,
-	unsigned int abbreviated_size)
+	int abbreviated_size)
 {
 	size_t size = abbreviated_size;
 	git_odb *odb;
@@ -383,7 +392,7 @@ static int find_unique_abbrev_size(
 
 	/* If we didn't find any shorter prefix, we have to do the whole thing */
 	*out = GIT_OID_HEXSZ;
-
+	
 	return 0;
 }
 
@@ -392,7 +401,7 @@ static int show_suffix(
 	int depth,
 	git_repository *repo,
 	const git_oid* id,
-	unsigned int abbrev_size)
+	size_t abbrev_size)
 {
 	int error, size = 0;
 
@@ -416,7 +425,7 @@ static int describe_not_found(const git_oid *oid, const char *message_format) {
 	char oid_str[GIT_OID_HEXSZ + 1];
 	git_oid_tostr(oid_str, sizeof(oid_str), oid);
 
-	git_error_set(GIT_ERROR_DESCRIBE, message_format, oid_str);
+	giterr_set(GITERR_DESCRIBE, message_format, oid_str);
 	return GIT_ENOTFOUND;
 }
 
@@ -495,7 +504,7 @@ static int describe(
 				unannotated_cnt++;
 			} else if (match_cnt < data->opts->max_candidates_tags) {
 				struct possible_tag *t = git__malloc(sizeof(struct commit_name));
-				GIT_ERROR_CHECK_ALLOC(t);
+				GITERR_CHECK_ALLOC(t);
 				if ((error = git_vector_insert(&all_matches, t)) < 0)
 					goto cleanup;
 
@@ -554,14 +563,14 @@ static int describe(
 			goto cleanup;
 		}
 		if (unannotated_cnt) {
-			error = describe_not_found(git_commit_id(commit),
+			error = describe_not_found(git_commit_id(commit), 
 				"cannot describe - "
 				"no annotated tags can describe '%s'; "
 			    "however, there were unannotated tags.");
 			goto cleanup;
 		}
 		else {
-			error = describe_not_found(git_commit_id(commit),
+			error = describe_not_found(git_commit_id(commit), 
 				"cannot describe - "
 				"no tags can describe '%s'.");
 			goto cleanup;
@@ -658,7 +667,7 @@ int git_describe_commit(
 	assert(committish);
 
 	data.result = git__calloc(1, sizeof(git_describe_result));
-	GIT_ERROR_CHECK_ALLOC(data.result);
+	GITERR_CHECK_ALLOC(data.result);
 	data.result->repo = git_object_owner(committish);
 
 	data.repo = git_object_owner(committish);
@@ -666,18 +675,18 @@ int git_describe_commit(
 	if ((error = normalize_options(&normalized, opts)) < 0)
 		return error;
 
-	GIT_ERROR_CHECK_VERSION(
+	GITERR_CHECK_VERSION(
 		&normalized,
 		GIT_DESCRIBE_OPTIONS_VERSION,
 		"git_describe_options");
 	data.opts = &normalized;
 
-	if ((error = git_oidmap_new(&data.names)) < 0)
-		return error;
+	data.names = git_oidmap_alloc();
+	GITERR_CHECK_ALLOC(data.names);
 
 	/** TODO: contains to be implemented */
 
-	if ((error = git_object_peel((git_object **)(&commit), committish, GIT_OBJECT_COMMIT)) < 0)
+	if ((error = git_object_peel((git_object **)(&commit), committish, GIT_OBJ_COMMIT)) < 0)
 		goto cleanup;
 
 	if ((error = git_reference_foreach_name(
@@ -686,7 +695,7 @@ int git_describe_commit(
 				goto cleanup;
 
 	if (git_oidmap_size(data.names) == 0 && !opts->show_commit_oid_as_fallback) {
-		git_error_set(GIT_ERROR_DESCRIBE, "cannot describe - "
+		giterr_set(GITERR_DESCRIBE, "cannot describe - "
 			"no reference found, cannot describe anything.");
 		error = -1;
 		goto cleanup;
@@ -729,7 +738,7 @@ int git_describe_workdir(
 	if ((error = git_reference_name_to_id(&current_id, repo, GIT_HEAD_FILE)) < 0)
 		return error;
 
-	if ((error = git_object_lookup(&commit, repo, &current_id, GIT_OBJECT_COMMIT)) < 0)
+	if ((error = git_object_lookup(&commit, repo, &current_id, GIT_OBJ_COMMIT)) < 0)
 		return error;
 
 	/* The first step is to perform a describe of HEAD, so we can leverage this */
@@ -760,7 +769,7 @@ static int normalize_format_options(
 	const git_describe_format_options *src)
 {
 	if (!src) {
-		git_describe_format_options_init(dst, GIT_DESCRIBE_FORMAT_OPTIONS_VERSION);
+		git_describe_init_format_options(dst, GIT_DESCRIBE_FORMAT_OPTIONS_VERSION);
 		return 0;
 	}
 
@@ -777,14 +786,14 @@ int git_describe_format(git_buf *out, const git_describe_result *result, const g
 
 	assert(out && result);
 
-	GIT_ERROR_CHECK_VERSION(given, GIT_DESCRIBE_FORMAT_OPTIONS_VERSION, "git_describe_format_options");
+	GITERR_CHECK_VERSION(given, GIT_DESCRIBE_FORMAT_OPTIONS_VERSION, "git_describe_format_options");
 	normalize_format_options(&opts, given);
 
 	git_buf_sanitize(out);
 
 
 	if (opts.always_use_long_format && opts.abbreviated_size == 0) {
-		git_error_set(GIT_ERROR_DESCRIBE, "cannot describe - "
+		giterr_set(GITERR_DESCRIBE, "cannot describe - "
 			"'always_use_long_format' is incompatible with a zero"
 			"'abbreviated_size'");
 		return -1;
@@ -869,26 +878,16 @@ void git_describe_result_free(git_describe_result *result)
 	git__free(result);
 }
 
-int git_describe_options_init(git_describe_options *opts, unsigned int version)
+int git_describe_init_options(git_describe_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_describe_options, GIT_DESCRIBE_OPTIONS_INIT);
 	return 0;
 }
 
-int git_describe_init_options(git_describe_options *opts, unsigned int version)
-{
-	return git_describe_options_init(opts, version);
-}
-
-int git_describe_format_options_init(git_describe_format_options *opts, unsigned int version)
+int git_describe_init_format_options(git_describe_format_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_describe_format_options, GIT_DESCRIBE_FORMAT_OPTIONS_INIT);
 	return 0;
 }
-
-int git_describe_init_format_options(git_describe_format_options *opts, unsigned int version)
-{
-	return git_describe_format_options_init(opts, version);
-}

data/vendor/libgit2/src/diff.c

@@ -114,7 +114,7 @@ int git_diff_is_sorted_icase(const git_diff *diff)
 int git_diff_get_perfdata(git_diff_perfdata *out, const git_diff *diff)
 {
 	assert(out);
-	GIT_ERROR_CHECK_VERSION(out, GIT_DIFF_PERFDATA_VERSION, "git_diff_perfdata");
+	GITERR_CHECK_VERSION(out, GIT_DIFF_PERFDATA_VERSION, "git_diff_perfdata");
 	out->stat_calls = diff->perf.stat_calls;
 	out->oid_calculations = diff->perf.oid_calculations;
 	return 0;
@@ -251,7 +251,7 @@ int git_diff_format_email(
 	assert(out && diff && opts);
 	assert(opts->summary && opts->id && opts->author);
 
-	GIT_ERROR_CHECK_VERSION(opts,
+	GITERR_CHECK_VERSION(opts,
 		GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION,
 		"git_format_email_options");
 
@@ -260,14 +260,14 @@ int git_diff_format_email(
 
 	if (!ignore_marker) {
 		if (opts->patch_no > opts->total_patches) {
-			git_error_set(GIT_ERROR_INVALID,
+			giterr_set(GITERR_INVALID,
 				"patch %"PRIuZ" out of range. max %"PRIuZ,
 				opts->patch_no, opts->total_patches);
 			return -1;
 		}
 
 		if (opts->patch_no == 0) {
-			git_error_set(GIT_ERROR_INVALID,
+			giterr_set(GITERR_INVALID,
 				"invalid patch no %"PRIuZ". should be >0", opts->patch_no);
 			return -1;
 		}
@@ -280,14 +280,14 @@ int git_diff_format_email(
 		size_t offset = 0;
 
 		if ((offset = (loc - opts->summary)) == 0) {
-			git_error_set(GIT_ERROR_INVALID, "summary is empty");
+			giterr_set(GITERR_INVALID, "summary is empty");
 			error = -1;
 			goto on_error;
 		}
 
-		GIT_ERROR_CHECK_ALLOC_ADD(&allocsize, offset, 1);
+		GITERR_CHECK_ALLOC_ADD(&allocsize, offset, 1);
 		summary = git__calloc(allocsize, sizeof(char));
-		GIT_ERROR_CHECK_ALLOC(summary);
+		GITERR_CHECK_ALLOC(summary);
 
 		strncpy(summary, opts->summary, offset);
 	}
@@ -323,7 +323,7 @@ int git_diff_commit_as_email(
 	git_commit *commit,
 	size_t patch_no,
 	size_t total_patches,
-	uint32_t flags,
+	git_diff_format_email_flags_t flags,
 	const git_diff_options *diff_opts)
 {
 	git_diff *diff = NULL;
@@ -350,19 +350,14 @@ int git_diff_commit_as_email(
 	return error;
 }
 
-int git_diff_options_init(git_diff_options *opts, unsigned int version)
+int git_diff_init_options(git_diff_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_diff_options, GIT_DIFF_OPTIONS_INIT);
 	return 0;
 }
 
-int git_diff_init_options(git_diff_options *opts, unsigned int version)
-{
-	return git_diff_options_init(opts, version);
-}
-
-int git_diff_find_options_init(
+int git_diff_find_init_options(
 	git_diff_find_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
@@ -370,13 +365,7 @@ int git_diff_find_options_init(
 	return 0;
 }
 
-int git_diff_find_init_options(
-	git_diff_find_options *opts, unsigned int version)
-{
-	return git_diff_find_options_init(opts, version);
-}
-
-int git_diff_format_email_options_init(
+int git_diff_format_email_init_options(
 	git_diff_format_email_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
@@ -385,12 +374,6 @@ int git_diff_format_email_options_init(
 	return 0;
 }
 
-int git_diff_format_email_init_options(
-	git_diff_format_email_options *opts, unsigned int version)
-{
-	return git_diff_format_email_options_init(opts, version);
-}
-
 static int flush_hunk(git_oid *result, git_hash_ctx *ctx)
 {
 	git_oid hash;
@@ -403,7 +386,7 @@ static int flush_hunk(git_oid *result, git_hash_ctx *ctx)
 
 	for (i = 0; i < GIT_OID_RAWSZ; i++) {
 		carry += result->id[i] + hash.id[i];
-		result->id[i] = (unsigned char)carry;
+		result->id[i] = carry;
 		carry >>= 8;
 	}
 
@@ -426,44 +409,79 @@ static void strip_spaces(git_buf *buf)
 	git_buf_truncate(buf, len);
 }
 
-int git_diff_patchid_print_callback__to_buf(
+static int file_cb(
 	const git_diff_delta *delta,
-	const git_diff_hunk *hunk,
-	const git_diff_line *line,
+	float progress,
 	void *payload)
 {
 	struct patch_id_args *args = (struct patch_id_args *) payload;
 	git_buf buf = GIT_BUF_INIT;
-	int error = 0;
+	int error;
 
-	if (line->origin == GIT_DIFF_LINE_CONTEXT_EOFNL ||
-	    line->origin == GIT_DIFF_LINE_ADD_EOFNL ||
-	    line->origin == GIT_DIFF_LINE_DEL_EOFNL)
-		goto out;
+	GIT_UNUSED(progress);
 
-	if ((error = git_diff_print_callback__to_buf(delta, hunk,
-						     line, &buf)) < 0)
+	if (!args->first_file &&
+	    (error = flush_hunk(&args->result, &args->ctx)) < 0)
+		goto out;
+	args->first_file = 0;
+
+	if ((error = git_buf_printf(&buf,
+				    "diff--gita/%sb/%s---a/%s+++b/%s",
+				    delta->old_file.path,
+				    delta->new_file.path,
+				    delta->old_file.path,
+				    delta->new_file.path)) < 0)
 		goto out;
 
 	strip_spaces(&buf);
 
-	if (line->origin == GIT_DIFF_LINE_FILE_HDR &&
-	    !args->first_file &&
-	    (error = flush_hunk(&args->result, &args->ctx) < 0))
-			goto out;
-
 	if ((error = git_hash_update(&args->ctx, buf.ptr, buf.size)) < 0)
 		goto out;
 
-	if (line->origin == GIT_DIFF_LINE_FILE_HDR && args->first_file)
-		args->first_file = 0;
+out:
+	git_buf_free(&buf);
+	return error;
+}
+
+static int line_cb(
+	const git_diff_delta *delta,
+	const git_diff_hunk *hunk,
+	const git_diff_line *line,
+	void *payload)
+{
+	struct patch_id_args *args = (struct patch_id_args *) payload;
+	git_buf buf = GIT_BUF_INIT;
+	int error;
+
+	GIT_UNUSED(delta);
+	GIT_UNUSED(hunk);
+
+	switch (line->origin) {
+	    case GIT_DIFF_LINE_ADDITION:
+		git_buf_putc(&buf, '+');
+		break;
+	    case GIT_DIFF_LINE_DELETION:
+		git_buf_putc(&buf, '-');
+		break;
+	    case GIT_DIFF_LINE_CONTEXT:
+		break;
+	    default:
+		giterr_set(GITERR_PATCH, "invalid line origin for patch");
+		return -1;
+	}
+
+	git_buf_put(&buf, line->content, line->content_len);
+	strip_spaces(&buf);
+
+	if ((error = git_hash_update(&args->ctx, buf.ptr, buf.size)) < 0)
+		goto out;
 
 out:
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 	return error;
 }
 
-int git_diff_patchid_options_init(git_diff_patchid_options *opts, unsigned int version)
+int git_diff_patchid_init_options(git_diff_patchid_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_diff_patchid_options, GIT_DIFF_PATCHID_OPTIONS_INIT);
@@ -475,7 +493,7 @@ int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opt
 	struct patch_id_args args;
 	int error;
 
-	GIT_ERROR_CHECK_VERSION(
+	GITERR_CHECK_VERSION(
 		opts, GIT_DIFF_PATCHID_OPTIONS_VERSION, "git_diff_patchid_options");
 
 	memset(&args, 0, sizeof(args));
@@ -483,10 +501,7 @@ int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opt
 	if ((error = git_hash_ctx_init(&args.ctx)) < 0)
 		goto out;
 
-	if ((error = git_diff_print(diff,
-				    GIT_DIFF_FORMAT_PATCH_ID,
-				    git_diff_patchid_print_callback__to_buf,
-				    &args)) < 0)
+	if ((error = git_diff_foreach(diff, file_cb, NULL, NULL, line_cb, &args)) < 0)
 		goto out;
 
 	if ((error = (flush_hunk(&args.result, &args.ctx))) < 0)