rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/iterator.h

@@ -41,8 +41,6 @@ typedef enum {
 	GIT_ITERATOR_INCLUDE_CONFLICTS = (1u << 6),
 	/** descend into symlinked directories */
 	GIT_ITERATOR_DESCEND_SYMLINKS = (1u << 7),
-	/** hash files in workdir or filesystem iterators */
-	GIT_ITERATOR_INCLUDE_HASH = (1u << 8),
 } git_iterator_flag_t;
 
 typedef enum {
@@ -291,19 +289,6 @@ extern int git_iterator_current_workdir_path(
  */
 extern git_index *git_iterator_index(git_iterator *iter);
 
-typedef int (*git_iterator_foreach_cb)(
-	const git_index_entry *entry,
-	void *data);
-
-/**
- * Walk the given iterator and invoke the callback for each path
- * contained in the iterator.
- */
-extern int git_iterator_foreach(
-	git_iterator *iterator,
-	git_iterator_foreach_cb cb,
-	void *data);
-
 typedef int (*git_iterator_walk_cb)(
 	const git_index_entry **entries,
 	void *data);

data/vendor/libgit2/src/khash.h

@@ -146,10 +146,8 @@ typedef unsigned long long khint64_t;
 #ifndef kh_inline
 #ifdef _MSC_VER
 #define kh_inline __inline
-#elif defined(__GNUC__)
-#define kh_inline __inline__
 #else
-#define kh_inline
+#define kh_inline inline
 #endif
 #endif /* kh_inline */
 

data/vendor/libgit2/src/map.h

@@ -40,7 +40,7 @@ typedef struct { /* memory mapped buffer	*/
 	assert((prot & GIT_PROT_WRITE) || (prot & GIT_PROT_READ)); \
 	assert((flags & GIT_MAP_FIXED) == 0); } while (0)
 
-extern int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, off64_t offset);
+extern int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset);
 extern int p_munmap(git_map *map);
 
 #endif

data/vendor/libgit2/src/merge.c

@@ -80,7 +80,7 @@ int merge_bases_many(git_commit_list **out, git_revwalk **walk_out, git_reposito
 	unsigned int i;
 
 	if (length < 2) {
-		git_error_set(GIT_ERROR_INVALID, "at least two commits are required to find an ancestor");
+		giterr_set(GITERR_INVALID, "at least two commits are required to find an ancestor");
 		return -1;
 	}
 
@@ -106,7 +106,7 @@ int merge_bases_many(git_commit_list **out, git_revwalk **walk_out, git_reposito
 		goto on_error;
 
 	if (!result) {
-		git_error_set(GIT_ERROR_MERGE, "no merge base found");
+		giterr_set(GITERR_MERGE, "no merge base found");
 		error = GIT_ENOTFOUND;
 		goto on_error;
 	}
@@ -186,7 +186,7 @@ int git_merge_base_octopus(git_oid *out, git_repository *repo, size_t length, co
 	assert(out && repo && input_array);
 
 	if (length < 2) {
-		git_error_set(GIT_ERROR_INVALID, "at least two commits are required to find an ancestor");
+		giterr_set(GITERR_INVALID, "at least two commits are required to find an ancestor");
 		return -1;
 	}
 
@@ -232,7 +232,7 @@ static int merge_bases(git_commit_list **out, git_revwalk **walk_out, git_reposi
 
 	if (!result) {
 		git_revwalk_free(walk);
-		git_error_set(GIT_ERROR_MERGE, "no merge base found");
+		giterr_set(GITERR_MERGE, "no merge base found");
 		return GIT_ENOTFOUND;
 	}
 
@@ -310,55 +310,46 @@ static int interesting(git_pqueue *list)
 	return 0;
 }
 
-static int clear_commit_marks_1(git_commit_list **plist,
+static void clear_commit_marks_1(git_commit_list **plist,
 		git_commit_list_node *commit, unsigned int mark)
 {
 	while (commit) {
 		unsigned int i;
 
 		if (!(mark & commit->flags))
-			return 0;
+			return;
 
 		commit->flags &= ~mark;
 
 		for (i = 1; i < commit->out_degree; i++) {
 			git_commit_list_node *p = commit->parents[i];
-			if (git_commit_list_insert(p, plist) == NULL)
-				return -1;
+			git_commit_list_insert(p, plist);
 		}
 
 		commit = commit->out_degree ? commit->parents[0] : NULL;
 	}
-
-	return 0;
 }
 
-static int clear_commit_marks_many(git_vector *commits, unsigned int mark)
+static void clear_commit_marks_many(git_vector *commits, unsigned int mark)
 {
 	git_commit_list *list = NULL;
 	git_commit_list_node *c;
 	unsigned int i;
 
 	git_vector_foreach(commits, i, c) {
-		if (git_commit_list_insert(c, &list) == NULL)
-			return -1;
+		git_commit_list_insert(c, &list);
 	}
 
 	while (list)
-		if (clear_commit_marks_1(&list, git_commit_list_pop(&list), mark) < 0)
-			return -1;
-	return 0;
+		clear_commit_marks_1(&list, git_commit_list_pop(&list), mark);
 }
 
-static int clear_commit_marks(git_commit_list_node *commit, unsigned int mark)
+static void clear_commit_marks(git_commit_list_node *commit, unsigned int mark)
 {
 	git_commit_list *list = NULL;
-	if (git_commit_list_insert(commit, &list) == NULL)
-		return -1;
+	git_commit_list_insert(commit, &list);
 	while (list)
-		if (clear_commit_marks_1(&list, git_commit_list_pop(&list), mark) < 0)
-			return -1;
-	return 0;
+		clear_commit_marks_1(&list, git_commit_list_pop(&list), mark);
 }
 
 static int paint_down_to_common(
@@ -435,9 +426,9 @@ static int remove_redundant(git_revwalk *walk, git_vector *commits)
 	int error = 0;
 
 	redundant = git__calloc(commits->length, 1);
-	GIT_ERROR_CHECK_ALLOC(redundant);
+	GITERR_CHECK_ALLOC(redundant);
 	filled_index = git__calloc((commits->length - 1), sizeof(unsigned int));
-	GIT_ERROR_CHECK_ALLOC(filled_index);
+	GITERR_CHECK_ALLOC(filled_index);
 
 	for (i = 0; i < commits->length; ++i) {
 		if ((error = git_commit_list_parse(walk, commits->contents[i])) < 0)
@@ -475,11 +466,10 @@ static int remove_redundant(git_revwalk *walk, git_vector *commits)
 				redundant[filled_index[j]] = 1;
 		}
 
-		git_commit_list_free(&common);
+		clear_commit_marks(commit, ALL_FLAGS);
+		clear_commit_marks_many(&work, ALL_FLAGS);
 
-		if ((error = clear_commit_marks(commit, ALL_FLAGS)) < 0 ||
-		    (error = clear_commit_marks_many(&work, ALL_FLAGS)) < 0)
-				goto done;
+		git_commit_list_free(&common);
 	}
 
 	for (i = 0; i < commits->length; ++i) {
@@ -541,9 +531,10 @@ int git_merge__bases_many(git_commit_list **out, git_revwalk *walk, git_commit_l
 		while (result)
 			git_vector_insert(&redundant, git_commit_list_pop(&result));
 
-		if ((error = clear_commit_marks(one, ALL_FLAGS)) < 0 ||
-		    (error = clear_commit_marks_many(twos, ALL_FLAGS)) < 0 ||
-		    (error = remove_redundant(walk, &redundant)) < 0) {
+		clear_commit_marks(one, ALL_FLAGS);
+		clear_commit_marks_many(twos, ALL_FLAGS);
+
+		if ((error = remove_redundant(walk, &redundant)) < 0) {
 			git_vector_free(&redundant);
 			return error;
 		}
@@ -585,7 +576,7 @@ int git_repository_mergehead_foreach(
 
 	while ((line = git__strsep(&buffer, "\n")) != NULL) {
 		if (strlen(line) != GIT_OID_HEXSZ) {
-			git_error_set(GIT_ERROR_INVALID, "unable to parse OID - invalid length");
+			giterr_set(GITERR_INVALID, "unable to parse OID - invalid length");
 			error = -1;
 			goto cleanup;
 		}
@@ -594,7 +585,7 @@ int git_repository_mergehead_foreach(
 			goto cleanup;
 
 		if ((error = cb(&oid, payload)) != 0) {
-			git_error_set_after_callback(error);
+			giterr_set_after_callback(error);
 			goto cleanup;
 		}
 
@@ -602,14 +593,14 @@ int git_repository_mergehead_foreach(
 	}
 
 	if (*buffer) {
-		git_error_set(GIT_ERROR_MERGE, "no EOL at line %"PRIuZ, line_num);
+		giterr_set(GITERR_MERGE, "no EOL at line %"PRIuZ, line_num);
 		error = -1;
 		goto cleanup;
 	}
 
 cleanup:
-	git_buf_dispose(&merge_head_path);
-	git_buf_dispose(&merge_head_file);
+	git_buf_free(&merge_head_path);
+	git_buf_free(&merge_head_file);
 
 	return error;
 }
@@ -868,23 +859,23 @@ static int merge_conflict_invoke_driver(
 
 	if ((error = driver->apply(driver, &path, &mode, &buf, name, src)) < 0 ||
 		(error = git_repository_odb(&odb, src->repo)) < 0 ||
-		(error = git_odb_write(&oid, odb, buf.ptr, buf.size, GIT_OBJECT_BLOB)) < 0)
+		(error = git_odb_write(&oid, odb, buf.ptr, buf.size, GIT_OBJ_BLOB)) < 0)
 		goto done;
 
 	result = git_pool_mallocz(&diff_list->pool, sizeof(git_index_entry));
-	GIT_ERROR_CHECK_ALLOC(result);
+	GITERR_CHECK_ALLOC(result);
 
 	git_oid_cpy(&result->id, &oid);
 	result->mode = mode;
-	result->file_size = (uint32_t)buf.size;
+	result->file_size = buf.size;
 
 	result->path = git_pool_strdup(&diff_list->pool, path);
-	GIT_ERROR_CHECK_ALLOC(result->path);
+	GITERR_CHECK_ALLOC(result->path);
 
 	*out = result;
 
 done:
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 	git_odb_free(odb);
 
 	return error;
@@ -1024,7 +1015,7 @@ static int index_entry_similarity_calc(
 {
 	git_blob *blob;
 	git_diff_file diff_file = {{{0}}};
-	git_object_size_t blobsize;
+	git_off_t blobsize;
 	int error;
 
 	*out = NULL;
@@ -1093,7 +1084,7 @@ static int index_entry_similarity_inexact(
 }
 
 /* Tracks deletes by oid for merge_diff_mark_similarity_exact().  This is a
-* non-shrinking queue where next_pos is the next position to dequeue.
+* non-shrinking queue where next_pos is the next position to dequeue. 
 */
 typedef struct {
 	git_array_t(size_t) arr;
@@ -1113,38 +1104,46 @@ static void deletes_by_oid_free(git_oidmap *map) {
 	git_oidmap_free(map);
 }
 
-static int deletes_by_oid_enqueue(git_oidmap *map, git_pool* pool, const git_oid *id, size_t idx)
-{
+static int deletes_by_oid_enqueue(git_oidmap *map, git_pool* pool, const git_oid *id, size_t idx) {
+	khint_t pos;
 	deletes_by_oid_queue *queue;
 	size_t *array_entry;
+	int error;
 
-	if ((queue = git_oidmap_get(map, id)) == NULL) {
+	pos = git_oidmap_lookup_index(map, id);
+	if (!git_oidmap_valid_index(map, pos)) {
 		queue = git_pool_malloc(pool, sizeof(deletes_by_oid_queue));
-		GIT_ERROR_CHECK_ALLOC(queue);
+		GITERR_CHECK_ALLOC(queue);
 
 		git_array_init(queue->arr);
 		queue->next_pos = 0;
 		queue->first_entry = idx;
 
-		if (git_oidmap_set(map, id, queue) < 0)
+		git_oidmap_insert(map, id, queue, &error);
+		if (error < 0)
 			return -1;
 	} else {
+		queue = git_oidmap_value_at(map, pos);
 		array_entry = git_array_alloc(queue->arr);
-		GIT_ERROR_CHECK_ALLOC(array_entry);
+		GITERR_CHECK_ALLOC(array_entry);
 		*array_entry = idx;
 	}
 
 	return 0;
 }
 
-static int deletes_by_oid_dequeue(size_t *idx, git_oidmap *map, const git_oid *id)
-{
+static int deletes_by_oid_dequeue(size_t *idx, git_oidmap *map, const git_oid *id) {
+	khint_t pos;
 	deletes_by_oid_queue *queue;
 	size_t *array_entry;
 
-	if ((queue = git_oidmap_get(map, id)) == NULL)
+	pos = git_oidmap_lookup_index(map, id);
+
+	if (!git_oidmap_valid_index(map, pos))
 		return GIT_ENOTFOUND;
 
+	queue = git_oidmap_value_at(map, pos);
+	
 	if (queue->next_pos == 0) {
 		*idx = queue->first_entry;
 	} else {
@@ -1169,8 +1168,8 @@ static int merge_diff_mark_similarity_exact(
 	git_oidmap *ours_deletes_by_oid = NULL, *theirs_deletes_by_oid = NULL;
 	int error = 0;
 
-	if (git_oidmap_new(&ours_deletes_by_oid) < 0 ||
-	    git_oidmap_new(&theirs_deletes_by_oid) < 0) {
+	if (!(ours_deletes_by_oid = git_oidmap_alloc()) ||
+		!(theirs_deletes_by_oid = git_oidmap_alloc())) {
 		error = -1;
 		goto done;
 	}
@@ -1511,11 +1510,11 @@ int git_merge_diff_list__find_renames(
 
 	similarity_ours = git__calloc(diff_list->conflicts.length,
 		sizeof(struct merge_diff_similarity));
-	GIT_ERROR_CHECK_ALLOC(similarity_ours);
+	GITERR_CHECK_ALLOC(similarity_ours);
 
 	similarity_theirs = git__calloc(diff_list->conflicts.length,
 		sizeof(struct merge_diff_similarity));
-	GIT_ERROR_CHECK_ALLOC(similarity_theirs);
+	GITERR_CHECK_ALLOC(similarity_theirs);
 
 	/* Calculate similarity between items that were deleted from the ancestor
 	 * and added in the other branch.
@@ -1524,9 +1523,9 @@ int git_merge_diff_list__find_renames(
 		goto done;
 
 	if (opts->rename_threshold < 100 && diff_list->conflicts.length <= opts->target_limit) {
-		GIT_ERROR_CHECK_ALLOC_MULTIPLY(&cache_size, diff_list->conflicts.length, 3);
+		GITERR_CHECK_ALLOC_MULTIPLY(&cache_size, diff_list->conflicts.length, 3);
 		cache = git__calloc(cache_size, sizeof(void *));
-		GIT_ERROR_CHECK_ALLOC(cache);
+		GITERR_CHECK_ALLOC(cache);
 
 		merge_diff_list_count_candidates(diff_list, &src_count, &tgt_count);
 
@@ -1740,7 +1739,7 @@ static int merge_diff_list_insert_unmodified(
 	git_index_entry *entry;
 
 	entry = git_pool_malloc(&diff_list->pool, sizeof(git_index_entry));
-	GIT_ERROR_CHECK_ALLOC(entry);
+	GITERR_CHECK_ALLOC(entry);
 
 	if ((error = index_entry_dup_pool(entry, &diff_list->pool, tree_items[0])) >= 0)
 		error = git_vector_insert(&diff_list->staged, entry);
@@ -1847,13 +1846,13 @@ static int merge_normalize_opts(
 
 	if (given && given->default_driver) {
 		opts->default_driver = git__strdup(given->default_driver);
-		GIT_ERROR_CHECK_ALLOC(opts->default_driver);
+		GITERR_CHECK_ALLOC(opts->default_driver);
 	} else {
 		error = git_config_get_entry(&entry, cfg, "merge.default");
 
 		if (error == 0) {
 			opts->default_driver = git__strdup(entry->value);
-			GIT_ERROR_CHECK_ALLOC(opts->default_driver);
+			GITERR_CHECK_ALLOC(opts->default_driver);
 		} else if (error == GIT_ENOTFOUND) {
 			error = 0;
 		} else {
@@ -1874,7 +1873,7 @@ static int merge_normalize_opts(
 	/* assign the internal metric with whitespace flag as payload */
 	if (!opts->metric) {
 		opts->metric = git__malloc(sizeof(git_diff_similarity_metric));
-		GIT_ERROR_CHECK_ALLOC(opts->metric);
+		GITERR_CHECK_ALLOC(opts->metric);
 
 		opts->metric->file_signature = git_diff_find_similar__hashsig_for_file;
 		opts->metric->buffer_signature = git_diff_find_similar__hashsig_for_buf;
@@ -2061,7 +2060,7 @@ int git_merge__iterators(
 
 	*out = NULL;
 
-	GIT_ERROR_CHECK_VERSION(
+	GITERR_CHECK_VERSION(
 		given_opts, GIT_MERGE_OPTIONS_VERSION, "git_merge_options");
 
 	if ((error = merge_normalize_opts(repo, &opts, given_opts)) < 0)
@@ -2080,7 +2079,7 @@ int git_merge__iterators(
 	}
 
 	diff_list = git_merge_diff_list__alloc(repo);
-	GIT_ERROR_CHECK_ALLOC(diff_list);
+	GITERR_CHECK_ALLOC(diff_list);
 
 	ancestor_iter = iterator_given_or_empty(&empty_ancestor, ancestor_iter);
 	our_iter = iterator_given_or_empty(&empty_ours, our_iter);
@@ -2103,7 +2102,7 @@ int git_merge__iterators(
 
 		if (!resolved) {
 			if ((opts.flags & GIT_MERGE_FAIL_ON_CONFLICT)) {
-				git_error_set(GIT_ERROR_MERGE, "merge conflicts exist");
+				giterr_set(GITERR_MERGE, "merge conflicts exist");
 				error = GIT_EMERGECONFLICT;
 				goto done;
 			}
@@ -2200,13 +2199,13 @@ GIT_INLINE(int) insert_head_ids(
 
 	if (annotated_commit->type == GIT_ANNOTATED_COMMIT_REAL) {
 		id = git_array_alloc(*ids);
-		GIT_ERROR_CHECK_ALLOC(id);
+		GITERR_CHECK_ALLOC(id);
 
 		git_oid_cpy(id, git_commit_id(annotated_commit->commit));
 	} else {
 		for (i = 0; i < annotated_commit->parents.size; i++) {
 			id = git_array_alloc(*ids);
-			GIT_ERROR_CHECK_ALLOC(id);
+			GITERR_CHECK_ALLOC(id);
 
 			git_oid_cpy(id, &annotated_commit->parents.ptr[i]);
 		}
@@ -2241,7 +2240,7 @@ static int create_virtual_base(
 		return -1;
 
 	result = git__calloc(1, sizeof(git_annotated_commit));
-	GIT_ERROR_CHECK_ALLOC(result);
+	GITERR_CHECK_ALLOC(result);
 	result->type = GIT_ANNOTATED_COMMIT_VIRTUAL;
 	result->index = index;
 
@@ -2369,7 +2368,7 @@ static int merge_annotated_commits(
 		if (error != GIT_ENOTFOUND)
 			goto done;
 
-		git_error_clear();
+		giterr_clear();
 	}
 
 	if ((error = iterator_for_annotated_commit(&base_iter, base)) < 0 ||
@@ -2431,7 +2430,7 @@ static int write_merge_head(
 	assert(repo && heads);
 
 	if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_MERGE_HEAD_FILE)) < 0 ||
-		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) < 0)
+		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_MERGE_FILE_MODE)) < 0)
 		goto cleanup;
 
 	for (i = 0; i < heads_len; i++) {
@@ -2445,7 +2444,7 @@ cleanup:
 	if (error < 0)
 		git_filebuf_cleanup(&file);
 
-	git_buf_dispose(&file_path);
+	git_buf_free(&file_path);
 
 	return error;
 }
@@ -2459,7 +2458,7 @@ static int write_merge_mode(git_repository *repo)
 	assert(repo);
 
 	if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_MERGE_MODE_FILE)) < 0 ||
-		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) < 0)
+		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_MERGE_FILE_MODE)) < 0)
 		goto cleanup;
 
 	if ((error = git_filebuf_write(&file, "no-ff", 5)) < 0)
@@ -2471,7 +2470,7 @@ cleanup:
 	if (error < 0)
 		git_filebuf_cleanup(&file);
 
-	git_buf_dispose(&file_path);
+	git_buf_free(&file_path);
 
 	return error;
 }
@@ -2679,7 +2678,7 @@ static int write_merge_msg(
 	assert(repo && heads);
 
 	entries = git__calloc(heads_len, sizeof(struct merge_msg_entry));
-	GIT_ERROR_CHECK_ALLOC(entries);
+	GITERR_CHECK_ALLOC(entries);
 
 	if (git_vector_init(&matching, heads_len, NULL) < 0) {
 		git__free(entries);
@@ -2690,7 +2689,7 @@ static int write_merge_msg(
 		entries[i].merge_head = heads[i];
 
 	if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 ||
-		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) < 0 ||
+		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_MERGE_FILE_MODE)) < 0 ||
 		(error = git_filebuf_write(&file, "Merge ", 6)) < 0)
 		goto cleanup;
 
@@ -2771,7 +2770,7 @@ cleanup:
 	if (error < 0)
 		git_filebuf_cleanup(&file);
 
-	git_buf_dispose(&file_path);
+	git_buf_free(&file_path);
 
 	git_vector_free(&matching);
 	git__free(entries);
@@ -2813,9 +2812,9 @@ static int merge_ancestor_head(
 
 	assert(repo && our_head && their_heads);
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, their_heads_len, 1);
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, their_heads_len, 1);
 	oids = git__calloc(alloc_len, sizeof(git_oid));
-	GIT_ERROR_CHECK_ALLOC(oids);
+	GITERR_CHECK_ALLOC(oids);
 
 	git_oid_cpy(&oids[0], git_commit_id(our_head->commit));
 
@@ -3039,7 +3038,7 @@ int git_merge__check_result(git_repository *repo, git_index *index_new)
 		goto done;
 
 	if ((conflicts = index_conflicts + wd_conflicts) > 0) {
-		git_error_set(GIT_ERROR_MERGE, "%" PRIuZ " uncommitted change%s would be overwritten by merge",
+		giterr_set(GITERR_MERGE, "%" PRIuZ " uncommitted change%s would be overwritten by merge",
 			conflicts, (conflicts != 1) ? "s" : "");
 		error = GIT_ECONFLICT;
 	}
@@ -3091,7 +3090,7 @@ cleanup:
 	if (error < 0)
 		git_filebuf_cleanup(&file);
 
-	git_buf_dispose(&file_path);
+	git_buf_free(&file_path);
 
 	return error;
 }
@@ -3111,24 +3110,28 @@ static int merge_heads(
 	git_annotated_commit **ancestor_head_out,
 	git_annotated_commit **our_head_out,
 	git_repository *repo,
-	git_reference *our_ref,
 	const git_annotated_commit **their_heads,
 	size_t their_heads_len)
 {
 	git_annotated_commit *ancestor_head = NULL, *our_head = NULL;
+	git_reference *our_ref = NULL;
 	int error = 0;
 
 	*ancestor_head_out = NULL;
 	*our_head_out = NULL;
 
-	if ((error = git_annotated_commit_from_ref(&our_head, repo, our_ref)) < 0)
+	if ((error = git_repository__ensure_not_bare(repo, "merge")) < 0)
+		goto done;
+
+	if ((error = git_reference_lookup(&our_ref, repo, GIT_HEAD_FILE)) < 0 ||
+		(error = git_annotated_commit_from_ref(&our_head, repo, our_ref)) < 0)
 		goto done;
 
 	if ((error = merge_ancestor_head(&ancestor_head, repo, our_head, their_heads, their_heads_len)) < 0) {
 		if (error != GIT_ENOTFOUND)
 			goto done;
 
-		git_error_clear();
+		giterr_clear();
 		error = 0;
 	}
 
@@ -3141,6 +3144,8 @@ done:
 		git_annotated_commit_free(our_head);
 	}
 
+	git_reference_free(our_ref);
+
 	return error;
 }
 
@@ -3157,7 +3162,7 @@ static int merge_preference(git_merge_preference_t *out, git_repository *repo)
 
 	if ((error = git_config_get_string(&value, config, "merge.ff")) < 0) {
 		if (error == GIT_ENOTFOUND) {
-			git_error_clear();
+			giterr_clear();
 			error = 0;
 		}
 
@@ -3177,22 +3182,20 @@ done:
 	return error;
 }
 
-int git_merge_analysis_for_ref(
+int git_merge_analysis(
 	git_merge_analysis_t *analysis_out,
 	git_merge_preference_t *preference_out,
 	git_repository *repo,
-	git_reference *our_ref,
 	const git_annotated_commit **their_heads,
 	size_t their_heads_len)
 {
 	git_annotated_commit *ancestor_head = NULL, *our_head = NULL;
 	int error = 0;
-	bool unborn;
 
-	assert(analysis_out && preference_out && repo && their_heads && their_heads_len > 0);
+	assert(analysis_out && preference_out && repo && their_heads);
 
 	if (their_heads_len != 1) {
-		git_error_set(GIT_ERROR_MERGE, "can only merge a single branch");
+		giterr_set(GITERR_MERGE, "can only merge a single branch");
 		error = -1;
 		goto done;
 	}
@@ -3202,16 +3205,12 @@ int git_merge_analysis_for_ref(
 	if ((error = merge_preference(preference_out, repo)) < 0)
 		goto done;
 
-	if ((error = git_reference__is_unborn_head(&unborn, our_ref, repo)) < 0)
-		goto done;
-
-	if (unborn) {
+	if (git_repository_head_unborn(repo)) {
 		*analysis_out |= GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_UNBORN;
-		error = 0;
 		goto done;
 	}
 
-	if ((error = merge_heads(&ancestor_head, &our_head, repo, our_ref, their_heads, their_heads_len)) < 0)
+	if ((error = merge_heads(&ancestor_head, &our_head, repo, their_heads, their_heads_len)) < 0)
 		goto done;
 
 	/* We're up-to-date if we're trying to merge our own common ancestor. */
@@ -3234,28 +3233,6 @@ done:
 	return error;
 }
 
-int git_merge_analysis(
-	git_merge_analysis_t *analysis_out,
-	git_merge_preference_t *preference_out,
-	git_repository *repo,
-	const git_annotated_commit **their_heads,
-	size_t their_heads_len)
-{
-	git_reference *head_ref = NULL;
-	int error = 0;
-
-	if ((error = git_reference_lookup(&head_ref, repo, GIT_HEAD_FILE)) < 0) {
-		git_error_set(GIT_ERROR_MERGE, "failed to lookup HEAD reference");
-		return error;
-	}
-
-	error = git_merge_analysis_for_ref(analysis_out, preference_out, repo, head_ref, their_heads, their_heads_len);
-
-	git_reference_free(head_ref);
-
-	return error;
-}
-
 int git_merge(
 	git_repository *repo,
 	const git_annotated_commit **their_heads,
@@ -3266,15 +3243,15 @@ int git_merge(
 	git_reference *our_ref = NULL;
 	git_checkout_options checkout_opts;
 	git_annotated_commit *our_head = NULL, *base = NULL;
-	git_index *repo_index = NULL, *index = NULL;
+	git_index *index = NULL;
 	git_indexwriter indexwriter = GIT_INDEXWRITER_INIT;
 	unsigned int checkout_strategy;
 	int error = 0;
 
-	assert(repo && their_heads && their_heads_len > 0);
+	assert(repo && their_heads);
 
 	if (their_heads_len != 1) {
-		git_error_set(GIT_ERROR_MERGE, "can only merge a single branch");
+		giterr_set(GITERR_MERGE, "can only merge a single branch");
 		return -1;
 	}
 
@@ -3289,10 +3266,6 @@ int git_merge(
 		&checkout_strategy)) < 0)
 		goto done;
 
-	if ((error = git_repository_index(&repo_index, repo) < 0) ||
-	    (error = git_index_read(repo_index, 0) < 0))
-		goto done;
-
 	/* Write the merge setup files to the repository. */
 	if ((error = git_annotated_commit_from_head(&our_head, repo)) < 0 ||
 		(error = git_merge__setup(repo, our_head, their_heads,
@@ -3326,45 +3299,28 @@ done:
 	git_annotated_commit_free(our_head);
 	git_annotated_commit_free(base);
 	git_reference_free(our_ref);
-	git_index_free(repo_index);
 
 	return error;
 }
 
-int git_merge_options_init(git_merge_options *opts, unsigned int version)
+int git_merge_init_options(git_merge_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_merge_options, GIT_MERGE_OPTIONS_INIT);
 	return 0;
 }
 
-int git_merge_init_options(git_merge_options *opts, unsigned int version)
-{
-	return git_merge_options_init(opts, version);
-}
-
-int git_merge_file_input_init(git_merge_file_input *input, unsigned int version)
+int git_merge_file_init_input(git_merge_file_input *input, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		input, version, git_merge_file_input, GIT_MERGE_FILE_INPUT_INIT);
 	return 0;
 }
 
-int git_merge_file_init_input(git_merge_file_input *input, unsigned int version)
-{
-	return git_merge_file_input_init(input, version);
-}
-
-int git_merge_file_options_init(
+int git_merge_file_init_options(
 	git_merge_file_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_merge_file_options, GIT_MERGE_FILE_OPTIONS_INIT);
 	return 0;
 }
-
-int git_merge_file_init_options(
-	git_merge_file_options *opts, unsigned int version)
-{
-	return git_merge_file_options_init(opts, version);
-}