rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/remote.h

@@ -29,23 +29,14 @@ struct git_remote {
 	git_transport *transport;
 	git_repository *repo;
 	git_push *push;
-	git_indexer_progress stats;
+	git_transfer_progress stats;
 	unsigned int need_pack;
 	git_remote_autotag_option_t download_tags;
 	int prune_refs;
 	int passed_refspecs;
 };
 
-typedef struct git_remote_connection_opts {
-	const git_strarray *custom_headers;
-	const git_proxy_options *proxy;
-} git_remote_connection_opts;
-
-#define GIT_REMOTE_CONNECTION_OPTIONS_INIT { NULL, NULL }
-
-int git_remote__connect(git_remote *remote, git_direction direction, const git_remote_callbacks *callbacks, const git_remote_connection_opts *conn);
-
-int git_remote__urlfordirection(git_buf *url_out, struct git_remote *remote, int direction, const git_remote_callbacks *callbacks);
+const char* git_remote__urlfordirection(struct git_remote *remote, int direction);
 int git_remote__get_http_proxy(git_remote *remote, bool use_ssl, char **proxy_url);
 
 git_refspec *git_remote__matching_refspec(git_remote *remote, const char *refname);

data/vendor/libgit2/src/repository.c

@@ -16,7 +16,7 @@
 #include "commit.h"
 #include "tag.h"
 #include "blob.h"
-#include "futils.h"
+#include "fileops.h"
 #include "sysdir.h"
 #include "filebuf.h"
 #include "index.h"
@@ -42,24 +42,23 @@ bool git_repository__fsync_gitdir = false;
 
 static const struct {
     git_repository_item_t parent;
-	git_repository_item_t fallback;
     const char *name;
     bool directory;
 } items[] = {
-	{ GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM__LAST, NULL, true },
-	{ GIT_REPOSITORY_ITEM_WORKDIR, GIT_REPOSITORY_ITEM__LAST, NULL, true },
-	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM__LAST, NULL, true },
-	{ GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM__LAST, "index", false },
-	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "objects", true },
-	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "refs", true },
-	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "packed-refs", false },
-	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "remotes", true },
-	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "config", false },
-	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "info", true },
-	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "hooks", true },
-	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "logs", true },
-	{ GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM__LAST, "modules", true },
-	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "worktrees", true }
+	{ GIT_REPOSITORY_ITEM_GITDIR, NULL, true },
+	{ GIT_REPOSITORY_ITEM_WORKDIR, NULL, true },
+	{ GIT_REPOSITORY_ITEM_COMMONDIR, NULL, true },
+	{ GIT_REPOSITORY_ITEM_GITDIR, "index", false },
+	{ GIT_REPOSITORY_ITEM_COMMONDIR, "objects", true },
+	{ GIT_REPOSITORY_ITEM_COMMONDIR, "refs", true },
+	{ GIT_REPOSITORY_ITEM_COMMONDIR, "packed-refs", false },
+	{ GIT_REPOSITORY_ITEM_COMMONDIR, "remotes", true },
+	{ GIT_REPOSITORY_ITEM_COMMONDIR, "config", false },
+	{ GIT_REPOSITORY_ITEM_COMMONDIR, "info", true },
+	{ GIT_REPOSITORY_ITEM_COMMONDIR, "hooks", true },
+	{ GIT_REPOSITORY_ITEM_COMMONDIR, "logs", true },
+	{ GIT_REPOSITORY_ITEM_GITDIR, "modules", true },
+	{ GIT_REPOSITORY_ITEM_COMMONDIR, "worktrees", true }
 };
 
 static int check_repositoryformatversion(git_config *config);
@@ -122,7 +121,7 @@ static void set_config(git_repository *repo, git_config *config)
 		git_config_free(config);
 	}
 
-	git_repository__configmap_lookup_cache_clear(repo);
+	git_repository__cvar_cache_clear(repo);
 }
 
 static void set_index(git_repository *repo, git_index *index)
@@ -161,13 +160,13 @@ void git_repository_free(git_repository *repo)
 
 	git_repository__cleanup(repo);
 
-	git_cache_dispose(&repo->objects);
+	git_cache_free(&repo->objects);
 
 	git_diff_driver_registry_free(repo->diff_drivers);
 	repo->diff_drivers = NULL;
 
 	for (i = 0; i < repo->reserved_names.size; i++)
-		git_buf_dispose(git_array_get(repo->reserved_names, i));
+		git_buf_free(git_array_get(repo->reserved_names, i));
 	git_array_clear(repo->reserved_names);
 
 	git__free(repo->gitlink);
@@ -204,7 +203,7 @@ static bool valid_repository_path(git_buf *repository_path, git_buf *common_path
 			git_buf_swap(common_path, &common_link);
 		}
 
-		git_buf_dispose(&common_link);
+		git_buf_free(&common_link);
 	}
 	else {
 		git_buf_set(common_path, repository_path->ptr, repository_path->size);
@@ -239,14 +238,14 @@ static git_repository *repository_alloc(void)
 	if (!repo->reserved_names.ptr)
 		goto on_error;
 
-	/* set all the entries in the configmap cache to `unset` */
-	git_repository__configmap_lookup_cache_clear(repo);
+	/* set all the entries in the cvar cache to `unset` */
+	git_repository__cvar_cache_clear(repo);
 
 	return repo;
 
 on_error:
 	if (repo)
-		git_cache_dispose(&repo->objects);
+		git_cache_free(&repo->objects);
 
 	git__free(repo);
 	return NULL;
@@ -257,7 +256,7 @@ int git_repository_new(git_repository **out)
 	git_repository *repo;
 
 	*out = repo = repository_alloc();
-	GIT_ERROR_CHECK_ALLOC(repo);
+	GITERR_CHECK_ALLOC(repo);
 
 	repo->is_bare = 1;
 	repo->is_worktree = 0;
@@ -332,9 +331,9 @@ static int load_workdir(git_repository *repo, git_config *config, git_buf *paren
 		repo->workdir = git_buf_detach(&worktree);
 	}
 
-	GIT_ERROR_CHECK_ALLOC(repo->workdir);
+	GITERR_CHECK_ALLOC(repo->workdir);
 cleanup:
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 	git_config_entry_free(ce);
 	return error;
 }
@@ -414,7 +413,7 @@ static int read_gitfile(git_buf *path_out, const char *file_path)
 	if (git_buf_len(&file) <= prefix_len ||
 		memcmp(git_buf_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
 	{
-		git_error_set(GIT_ERROR_REPOSITORY,
+		giterr_set(GITERR_REPOSITORY,
 			"the `.git` file at '%s' is malformed", file_path);
 		error = -1;
 	}
@@ -426,7 +425,7 @@ static int read_gitfile(git_buf *path_out, const char *file_path)
 			path_out, gitlink, git_buf_cstr(path_out));
 	}
 
-	git_buf_dispose(&file);
+	git_buf_free(&file);
 	return error;
 }
 
@@ -552,14 +551,14 @@ static int find_repo(
 	/* If we didn't find the repository, and we don't have any other error
 	 * to report, report that. */
 	if (!git_buf_len(gitdir_path) && !error) {
-		git_error_set(GIT_ERROR_REPOSITORY,
+		giterr_set(GITERR_REPOSITORY,
 			"could not find repository from '%s'", start_path);
 		error = GIT_ENOTFOUND;
 	}
 
-	git_buf_dispose(&path);
-	git_buf_dispose(&repo_link);
-	git_buf_dispose(&common_link);
+	git_buf_free(&path);
+	git_buf_free(&repo_link);
+	git_buf_free(&common_link);
 	return error;
 }
 
@@ -575,19 +574,19 @@ int git_repository_open_bare(
 		return error;
 
 	if (!valid_repository_path(&path, &common_path)) {
-		git_buf_dispose(&path);
-		git_buf_dispose(&common_path);
-		git_error_set(GIT_ERROR_REPOSITORY, "path is not a repository: %s", bare_path);
+		git_buf_free(&path);
+		git_buf_free(&common_path);
+		giterr_set(GITERR_REPOSITORY, "path is not a repository: %s", bare_path);
 		return GIT_ENOTFOUND;
 	}
 
 	repo = repository_alloc();
-	GIT_ERROR_CHECK_ALLOC(repo);
+	GITERR_CHECK_ALLOC(repo);
 
 	repo->gitdir = git_buf_detach(&path);
-	GIT_ERROR_CHECK_ALLOC(repo->gitdir);
+	GITERR_CHECK_ALLOC(repo->gitdir);
 	repo->commondir = git_buf_detach(&common_path);
-	GIT_ERROR_CHECK_ALLOC(repo->commondir);
+	GITERR_CHECK_ALLOC(repo->commondir);
 
 	/* of course we're bare! */
 	repo->is_bare = 1;
@@ -621,7 +620,7 @@ static int _git_repository_open_ext_from_env(
 	if (!start_path) {
 		error = git__getenv(&dir_buf, "GIT_DIR");
 		if (error == GIT_ENOTFOUND) {
-			git_error_clear();
+			giterr_clear();
 			start_path = ".";
 		} else if (error < 0)
 			goto error;
@@ -634,7 +633,7 @@ static int _git_repository_open_ext_from_env(
 
 	error = git__getenv(&ceiling_dirs_buf, "GIT_CEILING_DIRECTORIES");
 	if (error == GIT_ENOTFOUND)
-		git_error_clear();
+		giterr_clear();
 	else if (error < 0)
 		goto error;
 	else
@@ -642,7 +641,7 @@ static int _git_repository_open_ext_from_env(
 
 	error = git__getenv(&across_fs_buf, "GIT_DISCOVERY_ACROSS_FILESYSTEM");
 	if (error == GIT_ENOTFOUND)
-		git_error_clear();
+		giterr_clear();
 	else if (error < 0)
 		goto error;
 	else {
@@ -656,7 +655,7 @@ static int _git_repository_open_ext_from_env(
 
 	error = git__getenv(&index_file_buf, "GIT_INDEX_FILE");
 	if (error == GIT_ENOTFOUND)
-		git_error_clear();
+		giterr_clear();
 	else if (error < 0)
 		goto error;
 	else {
@@ -667,13 +666,13 @@ static int _git_repository_open_ext_from_env(
 
 	error = git__getenv(&namespace_buf, "GIT_NAMESPACE");
 	if (error == GIT_ENOTFOUND)
-		git_error_clear();
+		giterr_clear();
 	else if (error < 0)
 		goto error;
 
 	error = git__getenv(&object_dir_buf, "GIT_OBJECT_DIRECTORY");
 	if (error == GIT_ENOTFOUND)
-		git_error_clear();
+		giterr_clear();
 	else if (error < 0)
 		goto error;
 	else {
@@ -684,22 +683,22 @@ static int _git_repository_open_ext_from_env(
 
 	error = git__getenv(&work_tree_buf, "GIT_WORK_TREE");
 	if (error == GIT_ENOTFOUND)
-		git_error_clear();
+		giterr_clear();
 	else if (error < 0)
 		goto error;
 	else {
-		git_error_set(GIT_ERROR_INVALID, "GIT_WORK_TREE unimplemented");
+		giterr_set(GITERR_INVALID, "GIT_WORK_TREE unimplemented");
 		error = GIT_ERROR;
 		goto error;
 	}
 
 	error = git__getenv(&work_tree_buf, "GIT_COMMON_DIR");
 	if (error == GIT_ENOTFOUND)
-		git_error_clear();
+		giterr_clear();
 	else if (error < 0)
 		goto error;
 	else {
-		git_error_set(GIT_ERROR_INVALID, "GIT_COMMON_DIR unimplemented");
+		giterr_set(GITERR_INVALID, "GIT_COMMON_DIR unimplemented");
 		error = GIT_ERROR;
 		goto error;
 	}
@@ -713,7 +712,7 @@ static int _git_repository_open_ext_from_env(
 
 	error = git__getenv(&alts_buf, "GIT_ALTERNATE_OBJECT_DIRECTORIES");
 	if (error == GIT_ENOTFOUND) {
-		git_error_clear();
+		giterr_clear();
 		error = 0;
 	} else if (error < 0)
 		goto error;
@@ -755,15 +754,15 @@ error:
 success:
 	git_odb_free(odb);
 	git_index_free(index);
-	git_buf_dispose(&common_dir_buf);
-	git_buf_dispose(&work_tree_buf);
-	git_buf_dispose(&alts_buf);
-	git_buf_dispose(&object_dir_buf);
-	git_buf_dispose(&namespace_buf);
-	git_buf_dispose(&index_file_buf);
-	git_buf_dispose(&across_fs_buf);
-	git_buf_dispose(&ceiling_dirs_buf);
-	git_buf_dispose(&dir_buf);
+	git_buf_free(&common_dir_buf);
+	git_buf_free(&work_tree_buf);
+	git_buf_free(&alts_buf);
+	git_buf_free(&object_dir_buf);
+	git_buf_free(&namespace_buf);
+	git_buf_free(&index_file_buf);
+	git_buf_free(&across_fs_buf);
+	git_buf_free(&ceiling_dirs_buf);
+	git_buf_free(&dir_buf);
 	return error;
 }
 
@@ -786,7 +785,7 @@ static int repo_is_worktree(unsigned *out, const git_repository *repo)
 	 * only used when the repository is a working tree. */
 	*out = !!git_path_exists(gitdir_link.ptr);
 
-	git_buf_dispose(&gitdir_link);
+	git_buf_free(&gitdir_link);
 	return error;
 }
 
@@ -800,7 +799,7 @@ int git_repository_open_ext(
 	unsigned is_worktree;
 	git_buf gitdir = GIT_BUF_INIT, workdir = GIT_BUF_INIT,
 		gitlink = GIT_BUF_INIT, commondir = GIT_BUF_INIT;
-	git_repository *repo = NULL;
+	git_repository *repo;
 	git_config *config = NULL;
 
 	if (flags & GIT_REPOSITORY_OPEN_FROM_ENV)
@@ -813,21 +812,21 @@ int git_repository_open_ext(
 		&gitdir, &workdir, &gitlink, &commondir, start_path, flags, ceiling_dirs);
 
 	if (error < 0 || !repo_ptr)
-		goto cleanup;
+		return error;
 
 	repo = repository_alloc();
-	GIT_ERROR_CHECK_ALLOC(repo);
+	GITERR_CHECK_ALLOC(repo);
 
 	repo->gitdir = git_buf_detach(&gitdir);
-	GIT_ERROR_CHECK_ALLOC(repo->gitdir);
+	GITERR_CHECK_ALLOC(repo->gitdir);
 
 	if (gitlink.size) {
 		repo->gitlink = git_buf_detach(&gitlink);
-		GIT_ERROR_CHECK_ALLOC(repo->gitlink);
+		GITERR_CHECK_ALLOC(repo->gitlink);
 	}
 	if (commondir.size) {
 		repo->commondir = git_buf_detach(&commondir);
-		GIT_ERROR_CHECK_ALLOC(repo->commondir);
+		GITERR_CHECK_ALLOC(repo->commondir);
 	}
 
 	if ((error = repo_is_worktree(&is_worktree, repo)) < 0)
@@ -857,16 +856,13 @@ int git_repository_open_ext(
 	}
 
 cleanup:
-	git_buf_dispose(&gitdir);
-	git_buf_dispose(&workdir);
-	git_buf_dispose(&gitlink);
-	git_buf_dispose(&commondir);
+	git_buf_free(&gitdir);
+	git_buf_free(&workdir);
 	git_config_free(config);
 
 	if (error < 0)
 		git_repository_free(repo);
-
-	if (repo_ptr)
+	else
 		*repo_ptr = repo;
 
 	return error;
@@ -882,8 +878,7 @@ int git_repository_open_from_worktree(git_repository **repo_out, git_worktree *w
 {
 	git_buf path = GIT_BUF_INIT;
 	git_repository *repo = NULL;
-	size_t len;
-	int err;
+	int len, err;
 
 	assert(repo_out && wt);
 
@@ -904,7 +899,7 @@ int git_repository_open_from_worktree(git_repository **repo_out, git_worktree *w
 	*repo_out = repo;
 
 out:
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return err;
 }
@@ -914,7 +909,7 @@ int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb)
 	git_repository *repo;
 
 	repo = repository_alloc();
-	GIT_ERROR_CHECK_ALLOC(repo);
+	GITERR_CHECK_ALLOC(repo);
 
 	git_repository_set_odb(repo, odb);
 	*repo_out = repo;
@@ -949,20 +944,18 @@ static int load_config(
 	git_buf config_path = GIT_BUF_INIT;
 	git_config *cfg = NULL;
 
-	assert(out);
+	assert(repo && out);
 
 	if ((error = git_config_new(&cfg)) < 0)
 		return error;
 
-	if (repo) {
-		if ((error = git_repository_item_path(&config_path, repo, GIT_REPOSITORY_ITEM_CONFIG)) == 0)
-			error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, repo, 0);
+	if ((error = git_repository_item_path(&config_path, repo, GIT_REPOSITORY_ITEM_CONFIG)) == 0)
+		error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, repo, 0);
 
-		if (error && error != GIT_ENOTFOUND)
-			goto on_error;
+	if (error && error != GIT_ENOTFOUND)
+		goto on_error;
 
-		git_buf_dispose(&config_path);
-	}
+	git_buf_free(&config_path);
 
 	if (global_config_path != NULL &&
 		(error = git_config_add_file_ondisk(
@@ -988,13 +981,13 @@ static int load_config(
 		error != GIT_ENOTFOUND)
 		goto on_error;
 
-	git_error_clear(); /* clear any lingering ENOTFOUND errors */
+	giterr_clear(); /* clear any lingering ENOTFOUND errors */
 
 	*out = cfg;
 	return 0;
 
 on_error:
-	git_buf_dispose(&config_path);
+	git_buf_free(&config_path);
 	git_config_free(cfg);
 	*out = NULL;
 	return error;
@@ -1041,10 +1034,10 @@ int git_repository_config__weakptr(git_config **out, git_repository *repo)
 			}
 		}
 
-		git_buf_dispose(&global_buf);
-		git_buf_dispose(&xdg_buf);
-		git_buf_dispose(&system_buf);
-		git_buf_dispose(&programdata_buf);
+		git_buf_free(&global_buf);
+		git_buf_free(&xdg_buf);
+		git_buf_free(&system_buf);
+		git_buf_free(&programdata_buf);
 	}
 
 	*out = repo->_config;
@@ -1106,7 +1099,7 @@ int git_repository_odb__weakptr(git_odb **out, git_repository *repo)
 			git_odb_free(odb);
 		}
 
-		git_buf_dispose(&odb_path);
+		git_buf_free(&odb_path);
 	}
 
 	*out = repo->_odb;
@@ -1191,11 +1184,10 @@ int git_repository_index__weakptr(git_index **out, git_repository *repo)
 				git_index_free(index);
 			}
 
-			error = git_index_set_caps(repo->_index,
-			                           GIT_INDEX_CAPABILITY_FROM_OWNER);
+			error = git_index_set_caps(repo->_index, GIT_INDEXCAP_FROM_OWNER);
 		}
 
-		git_buf_dispose(&index_path);
+		git_buf_free(&index_path);
 	}
 
 	*out = repo->_index;
@@ -1290,8 +1282,8 @@ bool git_repository__reserved_names(
 			int (*prefixcmp)(const char *, const char *);
 			int error, ignorecase;
 
-			error = git_repository__configmap_lookup(
-				&ignorecase, repo, GIT_CONFIGMAP_IGNORECASE);
+			error = git_repository__cvar(
+				&ignorecase, repo, GIT_CVAR_IGNORECASE);
 			prefixcmp = (error || ignorecase) ? git__prefixcmp_icase :
 				git__prefixcmp;
 
@@ -1349,7 +1341,7 @@ static int check_repositoryformatversion(git_config *config)
 		return -1;
 
 	if (GIT_REPO_VERSION < version) {
-		git_error_set(GIT_ERROR_REPOSITORY,
+		giterr_set(GITERR_REPOSITORY,
 			"unsupported repository version %d. Only versions up to %d are supported.",
 			version, GIT_REPO_VERSION);
 		return -1;
@@ -1363,11 +1355,10 @@ int git_repository_create_head(const char *git_dir, const char *ref_name)
 	git_buf ref_path = GIT_BUF_INIT;
 	git_filebuf ref = GIT_FILEBUF_INIT;
 	const char *fmt;
-	int error;
 
-	if ((error = git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE)) < 0 ||
-	    (error = git_filebuf_open(&ref, ref_path.ptr, 0, GIT_REFS_FILE_MODE)) < 0)
-		goto out;
+	if (git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE) < 0 ||
+		git_filebuf_open(&ref, ref_path.ptr, 0, GIT_REFS_FILE_MODE) < 0)
+		goto fail;
 
 	if (!ref_name)
 		ref_name = GIT_BRANCH_MASTER;
@@ -1377,14 +1368,17 @@ int git_repository_create_head(const char *git_dir, const char *ref_name)
 	else
 		fmt = "ref: " GIT_REFS_HEADS_DIR "%s\n";
 
-	if ((error = git_filebuf_printf(&ref, fmt, ref_name)) < 0 ||
-	    (error = git_filebuf_commit(&ref)) < 0)
-		goto out;
+	if (git_filebuf_printf(&ref, fmt, ref_name) < 0 ||
+		git_filebuf_commit(&ref) < 0)
+		goto fail;
 
-out:
-	git_buf_dispose(&ref_path);
+	git_buf_free(&ref_path);
+	return 0;
+
+fail:
+	git_buf_free(&ref_path);
 	git_filebuf_cleanup(&ref);
-	return error;
+	return -1;
 }
 
 static bool is_chmod_supported(const char *file_path)
@@ -1411,53 +1405,30 @@ static bool is_filesystem_case_insensitive(const char *gitdir_path)
 	if (!git_buf_joinpath(&path, gitdir_path, "CoNfIg"))
 		is_insensitive = git_path_exists(git_buf_cstr(&path));
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 	return is_insensitive;
 }
 
 static bool are_symlinks_supported(const char *wd_path)
 {
-	git_config *config = NULL;
-	git_buf global_buf = GIT_BUF_INIT;
-	git_buf xdg_buf = GIT_BUF_INIT;
-	git_buf system_buf = GIT_BUF_INIT;
-	git_buf programdata_buf = GIT_BUF_INIT;
-	int symlinks = 0;
-
-	/*
-	 * To emulate Git for Windows, symlinks on Windows must be explicitly
-	 * opted-in.  We examine the system configuration for a core.symlinks
-	 * set to true.  If found, we then examine the filesystem to see if
-	 * symlinks are _actually_ supported by the current user.  If that is
-	 * _not_ set, then we do not test or enable symlink support.
-	 */
-#ifdef GIT_WIN32
-	git_config_find_global(&global_buf);
-	git_config_find_xdg(&xdg_buf);
-	git_config_find_system(&system_buf);
-	git_config_find_programdata(&programdata_buf);
-
-	if (load_config(&config, NULL,
-	    path_unless_empty(&global_buf),
-	    path_unless_empty(&xdg_buf),
-	    path_unless_empty(&system_buf),
-	    path_unless_empty(&programdata_buf)) < 0)
-		goto done;
-
-	if (git_config_get_bool(&symlinks, config, "core.symlinks") < 0 || !symlinks)
-		goto done;
-#endif
+	git_buf path = GIT_BUF_INIT;
+	int fd;
+	struct stat st;
+	int symlinks_supported = -1;
+
+	if ((fd = git_futils_mktmp(&path, wd_path, 0666)) < 0 ||
+		p_close(fd) < 0 ||
+		p_unlink(path.ptr) < 0 ||
+		p_symlink("testing", path.ptr) < 0 ||
+		p_lstat(path.ptr, &st) < 0)
+		symlinks_supported = false;
+	else
+		symlinks_supported = (S_ISLNK(st.st_mode) != 0);
 
-	if (!(symlinks = git_path_supports_symlinks(wd_path)))
-		goto done;
+	(void)p_unlink(path.ptr);
+	git_buf_free(&path);
 
-done:
-	git_buf_dispose(&global_buf);
-	git_buf_dispose(&xdg_buf);
-	git_buf_dispose(&system_buf);
-	git_buf_dispose(&programdata_buf);
-	git_config_free(config);
-	return symlinks != 0;
+	return symlinks_supported;
 }
 
 static int create_empty_file(const char *path, mode_t mode)
@@ -1465,12 +1436,12 @@ static int create_empty_file(const char *path, mode_t mode)
 	int fd;
 
 	if ((fd = p_creat(path, mode)) < 0) {
-		git_error_set(GIT_ERROR_OS, "error while creating '%s'", path);
+		giterr_set(GITERR_OS, "error while creating '%s'", path);
 		return -1;
 	}
 
 	if (p_close(fd) < 0) {
-		git_error_set(GIT_ERROR_OS, "error while closing '%s'", path);
+		giterr_set(GITERR_OS, "error while closing '%s'", path);
 		return -1;
 	}
 
@@ -1505,7 +1476,7 @@ static int repo_local_config(
 		return error;
 
 	if (git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL) < 0) {
-		git_error_clear();
+		giterr_clear();
 
 		if (!(error = git_config_add_file_ondisk(
 				parent, cfg_path, GIT_CONFIG_LEVEL_LOCAL, repo, false)))
@@ -1537,14 +1508,14 @@ static int repo_init_fs_configs(
 		if ((error = git_config_set_bool(cfg, "core.symlinks", false)) < 0)
 			return error;
 	} else if (git_config_delete_entry(cfg, "core.symlinks") < 0)
-		git_error_clear();
+		giterr_clear();
 
 	if (update_ignorecase) {
 		if (is_filesystem_case_insensitive(repo_dir)) {
 			if ((error = git_config_set_bool(cfg, "core.ignorecase", true)) < 0)
 				return error;
 		} else if (git_config_delete_entry(cfg, "core.ignorecase") < 0)
-			git_error_clear();
+			giterr_clear();
 	}
 
 #ifdef GIT_USE_ICONV
@@ -1601,7 +1572,7 @@ static int repo_init_config(
 			SET_REPO_CONFIG(string, "core.worktree", worktree_path.ptr);
 		} else if (is_reinit) {
 			if (git_config_delete_entry(config, "core.worktree") < 0)
-				git_error_clear();
+				giterr_clear();
 		}
 	}
 
@@ -1615,8 +1586,8 @@ static int repo_init_config(
 	}
 
 cleanup:
-	git_buf_dispose(&cfg_path);
-	git_buf_dispose(&worktree_path);
+	git_buf_free(&cfg_path);
+	git_buf_free(&worktree_path);
 	git_config_free(config);
 
 	return error;
@@ -1629,7 +1600,7 @@ static int repo_reinit_submodule_fs(git_submodule *sm, const char *n, void *p)
 
 	if (git_submodule_open(&smrepo, sm) < 0 ||
 		git_repository_reinit_filesystem(smrepo, true) < 0)
-		git_error_clear();
+		giterr_clear();
 	git_repository_free(smrepo);
 
 	return 0;
@@ -1647,9 +1618,9 @@ int git_repository_reinit_filesystem(git_repository *repo, int recurse)
 			config, path.ptr, repo_dir, git_repository_workdir(repo), true);
 
 	git_config_free(config);
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
-	git_repository__configmap_lookup_cache_clear(repo);
+	git_repository__cvar_cache_clear(repo);
 
 	if (!repo->is_bare && recurse)
 		(void)git_submodule_foreach(repo, repo_reinit_submodule_fs, NULL);
@@ -1695,10 +1666,10 @@ static int repo_write_template(
 	GIT_UNUSED(hidden);
 #endif
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	if (error)
-		git_error_set(GIT_ERROR_OS,
+		giterr_set(GITERR_OS,
 			"failed to initialize repository with template '%s'", file);
 
 	return error;
@@ -1729,7 +1700,7 @@ static int repo_write_gitlink(
 		goto cleanup;
 
 	if (!p_stat(buf.ptr, &st) && !S_ISREG(st.st_mode)) {
-		git_error_set(GIT_ERROR_REPOSITORY,
+		giterr_set(GITERR_REPOSITORY,
 			"cannot overwrite gitlink file into path '%s'", in_dir);
 		error = GIT_EEXISTS;
 		goto cleanup;
@@ -1749,8 +1720,8 @@ static int repo_write_gitlink(
 		error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr);
 
 cleanup:
-	git_buf_dispose(&buf);
-	git_buf_dispose(&path_to_repo);
+	git_buf_free(&buf);
+	git_buf_free(&path_to_repo);
 	return error;
 }
 
@@ -1783,7 +1754,7 @@ static int repo_init_structure(
 #ifdef GIT_WIN32
 	if ((opts->flags & GIT_REPOSITORY_INIT__HAS_DOTGIT) != 0) {
 		if (git_win32__set_hidden(repo_dir, true) < 0) {
-			git_error_set(GIT_ERROR_OS,
+			giterr_set(GITERR_OS,
 				"failed to mark Git repository folder as hidden");
 			return -1;
 		}
@@ -1810,7 +1781,7 @@ static int repo_init_structure(
 		else if ((error = git_config_open_default(&cfg)) >= 0) {
 			if (!git_config_get_path(&template_buf, cfg, "init.templatedir"))
 				tdir = template_buf.ptr;
-			git_error_clear();
+			giterr_clear();
 		}
 
 		if (!tdir) {
@@ -1834,7 +1805,7 @@ static int repo_init_structure(
 			error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode);
 		}
 
-		git_buf_dispose(&template_buf);
+		git_buf_free(&template_buf);
 		git_config_free(cfg);
 
 		if (error < 0) {
@@ -1842,7 +1813,7 @@ static int repo_init_structure(
 				return error;
 
 			/* if template was default, ignore error and use internal */
-			git_error_clear();
+			giterr_clear();
 			external_tpl = false;
 			error = 0;
 		}
@@ -1944,7 +1915,7 @@ static int repo_init_directories(
 			if (git_path_dirname_r(wd_path, repo_path->ptr) < 0)
 				return -1;
 		} else {
-			git_error_set(GIT_ERROR_REPOSITORY, "cannot pick working directory"
+			giterr_set(GITERR_REPOSITORY, "cannot pick working directory"
 				" for non-bare repository that isn't a '.git' directory");
 			return -1;
 		}
@@ -2047,62 +2018,56 @@ int git_repository_init_ext(
 	const char *given_repo,
 	git_repository_init_options *opts)
 {
+	int error;
 	git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT,
-		common_path = GIT_BUF_INIT, head_path = GIT_BUF_INIT;
+		common_path = GIT_BUF_INIT;
 	const char *wd;
-	int error;
 
 	assert(out && given_repo && opts);
 
-	GIT_ERROR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
+	GITERR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
 
-	if ((error = repo_init_directories(&repo_path, &wd_path, given_repo, opts)) < 0)
-		goto out;
+	error = repo_init_directories(&repo_path, &wd_path, given_repo, opts);
+	if (error < 0)
+		goto cleanup;
 
 	wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_buf_cstr(&wd_path);
-
 	if (valid_repository_path(&repo_path, &common_path)) {
+
 		if ((opts->flags & GIT_REPOSITORY_INIT_NO_REINIT) != 0) {
-			git_error_set(GIT_ERROR_REPOSITORY,
+			giterr_set(GITERR_REPOSITORY,
 				"attempt to reinitialize '%s'", given_repo);
 			error = GIT_EEXISTS;
-			goto out;
+			goto cleanup;
 		}
 
 		opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;
 
-		if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0)
-			goto out;
+		error = repo_init_config(
+			repo_path.ptr, wd, opts->flags, opts->mode);
 
 		/* TODO: reinitialize the templates */
-	} else {
-		if ((error = repo_init_structure(repo_path.ptr, wd, opts)) < 0 ||
-		    (error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0 ||
-		    (error = git_buf_joinpath(&head_path, repo_path.ptr, GIT_HEAD_FILE)) < 0)
-			goto out;
-
-		/*
-		 * Only set the new HEAD if the file does not exist already via
-		 * a template or if the caller has explicitly supplied an
-		 * initial HEAD value.
-		 */
-		if ((!git_path_exists(head_path.ptr) || opts->initial_head) &&
-		    (error = git_repository_create_head(repo_path.ptr, opts->initial_head)) < 0)
-			goto out;
 	}
+	else {
+		if (!(error = repo_init_structure(
+				repo_path.ptr, wd, opts)) &&
+			!(error = repo_init_config(
+				repo_path.ptr, wd, opts->flags, opts->mode)))
+			error = git_repository_create_head(
+				repo_path.ptr, opts->initial_head);
+	}
+	if (error < 0)
+		goto cleanup;
 
-	if ((error = git_repository_open(out, repo_path.ptr)) < 0)
-		goto out;
+	error = git_repository_open(out, repo_path.ptr);
 
-	if (opts->origin_url &&
-	    (error = repo_init_create_origin(*out, opts->origin_url)) < 0)
-		goto out;
+	if (!error && opts->origin_url)
+		error = repo_init_create_origin(*out, opts->origin_url);
 
-out:
-	git_buf_dispose(&head_path);
-	git_buf_dispose(&common_path);
-	git_buf_dispose(&repo_path);
-	git_buf_dispose(&wd_path);
+cleanup:
+	git_buf_free(&common_path);
+	git_buf_free(&repo_path);
+	git_buf_free(&wd_path);
 
 	return error;
 }
@@ -2119,7 +2084,7 @@ int git_repository_head_detached(git_repository *repo)
 	if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
 		return -1;
 
-	if (git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC) {
+	if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
 		git_reference_free(ref);
 		return 0;
 	}
@@ -2146,7 +2111,7 @@ int git_repository_head_detached_for_worktree(git_repository *repo, const char *
 	if ((error = git_repository_head_for_worktree(&ref, repo, name)) < 0)
 		goto out;
 
-	error = (git_reference_type(ref) != GIT_REFERENCE_SYMBOLIC);
+	error = (git_reference_type(ref) != GIT_REF_SYMBOLIC);
 out:
 	git_reference_free(ref);
 
@@ -2158,12 +2123,10 @@ int git_repository_head(git_reference **head_out, git_repository *repo)
 	git_reference *head;
 	int error;
 
-	assert(head_out);
-
 	if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
 		return error;
 
-	if (git_reference_type(head) == GIT_REFERENCE_DIRECT) {
+	if (git_reference_type(head) == GIT_REF_OID) {
 		*head_out = head;
 		return 0;
 	}
@@ -2188,7 +2151,7 @@ int git_repository_head_for_worktree(git_reference **out, git_repository *repo,
 	    (error = git_reference__read_head(&head, repo, path.ptr)) < 0)
 		goto out;
 
-	if (git_reference_type(head) != GIT_REFERENCE_DIRECT) {
+	if (git_reference_type(head) != GIT_REF_OID) {
 		git_reference *resolved;
 
 		error = git_reference_lookup_resolved(&resolved, repo, git_reference_symbolic_target(head), -1);
@@ -2202,46 +2165,39 @@ out:
 	if (error)
 		git_reference_free(head);
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
 }
 
-int git_repository_foreach_head(git_repository *repo,
-				git_repository_foreach_head_cb cb,
-				int flags, void *payload)
+int git_repository_foreach_head(git_repository *repo, git_repository_foreach_head_cb cb, void *payload)
 {
 	git_strarray worktrees = GIT_VECTOR_INIT;
 	git_buf path = GIT_BUF_INIT;
-	int error = 0;
+	int error;
 	size_t i;
 
+	/* Execute callback for HEAD of commondir */
+	if ((error = git_buf_joinpath(&path, repo->commondir, GIT_HEAD_FILE)) < 0 ||
+	    (error = cb(repo, path.ptr, payload) != 0))
+		goto out;
 
-	if (!(flags & GIT_REPOSITORY_FOREACH_HEAD_SKIP_REPO)) {
-		/* Gather HEAD of main repository */
-		if ((error = git_buf_joinpath(&path, repo->commondir, GIT_HEAD_FILE)) < 0 ||
-		    (error = cb(repo, path.ptr, payload) != 0))
-			goto out;
+	if ((error = git_worktree_list(&worktrees, repo)) < 0) {
+		error = 0;
+		goto out;
 	}
 
-	if (!(flags & GIT_REPOSITORY_FOREACH_HEAD_SKIP_WORKTREES)) {
-		if ((error = git_worktree_list(&worktrees, repo)) < 0) {
-			error = 0;
-			goto out;
-		}
-
-		/* Gather HEADs of all worktrees */
-		for (i = 0; i < worktrees.count; i++) {
-			if (get_worktree_file_path(&path, repo, worktrees.strings[i], GIT_HEAD_FILE) < 0)
-				continue;
+	/* Execute callback for all worktree HEADs */
+	for (i = 0; i < worktrees.count; i++) {
+		if (get_worktree_file_path(&path, repo, worktrees.strings[i], GIT_HEAD_FILE) < 0)
+			continue;
 
-			if ((error = cb(repo, path.ptr, payload)) != 0)
-				goto out;
-		}
+		if ((error = cb(repo, path.ptr, payload)) != 0)
+			goto out;
 	}
 
 out:
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 	git_strarray_free(&worktrees);
 	return error;
 }
@@ -2255,7 +2211,7 @@ int git_repository_head_unborn(git_repository *repo)
 	git_reference_free(ref);
 
 	if (error == GIT_EUNBORNBRANCH) {
-		git_error_clear();
+		giterr_clear();
 		return 1;
 	}
 
@@ -2293,7 +2249,7 @@ int git_repository_is_empty(git_repository *repo)
 	if (git_reference_lookup(&head, repo, GIT_HEAD_FILE) < 0)
 		return -1;
 
-	if (git_reference_type(head) == GIT_REFERENCE_SYMBOLIC)
+	if (git_reference_type(head) == GIT_REF_SYMBOLIC)
 		is_empty =
 			(strcmp(git_reference_symbolic_target(head),
 					GIT_REFS_HEADS_DIR "master") == 0) &&
@@ -2304,11 +2260,11 @@ int git_repository_is_empty(git_repository *repo)
 	return is_empty;
 }
 
-static const char *resolved_parent_path(const git_repository *repo, git_repository_item_t item, git_repository_item_t fallback)
+int git_repository_item_path(git_buf *out, const git_repository *repo, git_repository_item_t item)
 {
 	const char *parent;
 
-	switch (item) {
+	switch (items[item].parent) {
 		case GIT_REPOSITORY_ITEM_GITDIR:
 			parent = git_repository_path(repo);
 			break;
@@ -2319,20 +2275,12 @@ static const char *resolved_parent_path(const git_repository *repo, git_reposito
 			parent = git_repository_commondir(repo);
 			break;
 		default:
-			git_error_set(GIT_ERROR_INVALID, "invalid item directory");
-			return NULL;
+			giterr_set(GITERR_INVALID, "invalid item directory");
+			return -1;
 	}
-	if (!parent && fallback != GIT_REPOSITORY_ITEM__LAST)
-		return resolved_parent_path(repo, fallback, GIT_REPOSITORY_ITEM__LAST);
-
-	return parent;
-}
 
-int git_repository_item_path(git_buf *out, const git_repository *repo, git_repository_item_t item)
-{
-	const char *parent = resolved_parent_path(repo, items[item].parent, items[item].fallback);
 	if (parent == NULL) {
-		git_error_set(GIT_ERROR_INVALID, "path cannot exist in repository");
+		giterr_set(GITERR_INVALID, "path cannot exist in repository");
 		return GIT_ENOTFOUND;
 	}
 
@@ -2465,7 +2413,7 @@ int git_repository_head_tree(git_tree **tree, git_repository *repo)
 	if ((error = git_repository_head(&head, repo)) < 0)
 		return error;
 
-	if ((error = git_reference_peel(&obj, head, GIT_OBJECT_TREE)) < 0)
+	if ((error = git_reference_peel(&obj, head, GIT_OBJ_TREE)) < 0)
 		goto cleanup;
 
 	*tree = (git_tree *)obj;
@@ -2485,14 +2433,14 @@ int git_repository__set_orig_head(git_repository *repo, const git_oid *orig_head
 	git_oid_fmt(orig_head_str, orig_head);
 
 	if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_ORIG_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 &&
 		(error = git_filebuf_printf(&file, "%.*s\n", GIT_OID_HEXSZ, orig_head_str)) == 0)
 		error = git_filebuf_commit(&file);
 
 	if (error < 0)
 		git_filebuf_cleanup(&file);
 
-	git_buf_dispose(&file_path);
+	git_buf_free(&file_path);
 
 	return error;
 }
@@ -2511,12 +2459,12 @@ int git_repository_message(git_buf *out, git_repository *repo)
 	if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) {
 		if (errno == ENOENT)
 			error = GIT_ENOTFOUND;
-		git_error_set(GIT_ERROR_OS, "could not access message file");
+		giterr_set(GITERR_OS, "could not access message file");
 	} else {
 		error = git_futils_readbuffer(out, git_buf_cstr(&path));
 	}
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
 }
@@ -2530,7 +2478,7 @@ int git_repository_message_remove(git_repository *repo)
 		return -1;
 
 	error = p_unlink(git_buf_cstr(&path));
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
 }
@@ -2539,13 +2487,13 @@ int git_repository_hashfile(
 	git_oid *out,
 	git_repository *repo,
 	const char *path,
-	git_object_t type,
+	git_otype type,
 	const char *as_path)
 {
 	int error;
 	git_filter_list *fl = NULL;
 	git_file fd = -1;
-	uint64_t len;
+	git_off_t len;
 	git_buf full_path = GIT_BUF_INIT;
 
 	assert(out && path && repo); /* as_path can be NULL */
@@ -2582,11 +2530,14 @@ int git_repository_hashfile(
 		goto cleanup;
 	}
 
-	if ((error = git_futils_filesize(&len, fd)) < 0)
+	len = git_futils_filesize(fd);
+	if (len < 0) {
+		error = (int)len;
 		goto cleanup;
+	}
 
 	if (!git__is_sizet(len)) {
-		git_error_set(GIT_ERROR_OS, "file size overflow for 32-bit systems");
+		giterr_set(GITERR_OS, "file size overflow for 32-bit systems");
 		error = -1;
 		goto cleanup;
 	}
@@ -2597,7 +2548,7 @@ cleanup:
 	if (fd >= 0)
 		p_close(fd);
 	git_filter_list_free(fl);
-	git_buf_dispose(&full_path);
+	git_buf_free(&full_path);
 
 	return error;
 }
@@ -2606,7 +2557,7 @@ static int checkout_message(git_buf *out, git_reference *old, const char *new)
 {
 	git_buf_puts(out, "checkout: moving from ");
 
-	if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC)
+	if (git_reference_type(old) == GIT_REF_SYMBOLIC)
 		git_buf_puts(out, git_reference__shorthand(git_reference_symbolic_target(old)));
 	else
 		git_buf_puts(out, git_oid_tostr_s(git_reference_target(old)));
@@ -2638,10 +2589,10 @@ static int detach(git_repository *repo, const git_oid *id, const char *new)
 	if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
 		return error;
 
-	if ((error = git_object_lookup(&object, repo, id, GIT_OBJECT_ANY)) < 0)
+	if ((error = git_object_lookup(&object, repo, id, GIT_OBJ_ANY)) < 0)
 		goto cleanup;
 
-	if ((error = git_object_peel(&peeled, object, GIT_OBJECT_COMMIT)) < 0)
+	if ((error = git_object_peel(&peeled, object, GIT_OBJ_COMMIT)) < 0)
 		goto cleanup;
 
 	if (new == NULL)
@@ -2653,7 +2604,7 @@ static int detach(git_repository *repo, const git_oid *id, const char *new)
 	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, git_buf_cstr(&log_message));
 
 cleanup:
-	git_buf_dispose(&log_message);
+	git_buf_free(&log_message);
 	git_object_free(object);
 	git_object_free(peeled);
 	git_reference_free(current);
@@ -2681,9 +2632,9 @@ int git_repository_set_head(
 	if (error < 0 && error != GIT_ENOTFOUND)
 		goto cleanup;
 
-	if (ref && current->type == GIT_REFERENCE_SYMBOLIC && git__strcmp(current->target.symbolic, ref->name) &&
+	if (ref && current->type == GIT_REF_SYMBOLIC && git__strcmp(current->target.symbolic, ref->name) &&
 	    git_reference_is_branch(ref) && git_branch_is_checked_out(ref)) {
-		git_error_set(GIT_ERROR_REPOSITORY, "cannot set HEAD to reference '%s' as it is the current HEAD "
+		giterr_set(GITERR_REPOSITORY, "cannot set HEAD to reference '%s' as it is the current HEAD "
 			"of a linked repository.", git_reference_name(ref));
 		error = -1;
 		goto cleanup;
@@ -2703,7 +2654,7 @@ int git_repository_set_head(
 	}
 
 cleanup:
-	git_buf_dispose(&log_message);
+	git_buf_free(&log_message);
 	git_reference_free(current);
 	git_reference_free(ref);
 	git_reference_free(new_head);
@@ -2741,7 +2692,7 @@ int git_repository_detach_head(git_repository* repo)
 	if ((error = git_repository_head(&old_head, repo)) < 0)
 		goto cleanup;
 
-	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJECT_COMMIT)) < 0)
+	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJ_COMMIT)) < 0)
 		goto cleanup;
 
 	if ((error = checkout_message(&log_message, current, git_oid_tostr_s(git_object_id(object)))) < 0)
@@ -2751,7 +2702,7 @@ int git_repository_detach_head(git_repository* repo)
 			1, git_buf_cstr(&log_message));
 
 cleanup:
-	git_buf_dispose(&log_message);
+	git_buf_free(&log_message);
 	git_object_free(object);
 	git_reference_free(old_head);
 	git_reference_free(new_head);
@@ -2798,7 +2749,7 @@ int git_repository_state(git_repository *repo)
 	} else if (git_path_contains_file(&repo_path, GIT_BISECT_LOG_FILE))
 		state = GIT_REPOSITORY_STATE_BISECT;
 
-	git_buf_dispose(&repo_path);
+	git_buf_free(&repo_path);
 	return state;
 }
 
@@ -2827,7 +2778,7 @@ int git_repository__cleanup_files(
 		git_buf_clear(&buf);
 	}
 
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 	return error;
 }
 
@@ -2860,10 +2811,10 @@ int git_repository_is_shallow(git_repository *repo)
 		return error;
 
 	error = git_path_lstat(path.ptr, &st);
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	if (error == GIT_ENOTFOUND) {
-		git_error_clear();
+		giterr_clear();
 		return 0;
 	}
 
@@ -2872,7 +2823,7 @@ int git_repository_is_shallow(git_repository *repo)
 	return st.st_size == 0 ? 0 : 1;
 }
 
-int git_repository_init_options_init(
+int git_repository_init_init_options(
 	git_repository_init_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
@@ -2881,12 +2832,6 @@ int git_repository_init_options_init(
 	return 0;
 }
 
-int git_repository_init_init_options(
-	git_repository_init_options *opts, unsigned int version)
-{
-	return git_repository_init_options_init(opts, version);
-}
-
 int git_repository_ident(const char **name, const char **email, const git_repository *repo)
 {
 	*name = repo->ident_name;
@@ -2901,12 +2846,12 @@ int git_repository_set_ident(git_repository *repo, const char *name, const char
 
 	if (name) {
 		tmp_name = git__strdup(name);
-		GIT_ERROR_CHECK_ALLOC(tmp_name);
+		GITERR_CHECK_ALLOC(tmp_name);
 	}
 
 	if (email) {
 		tmp_email = git__strdup(email);
-		GIT_ERROR_CHECK_ALLOC(tmp_email);
+		GITERR_CHECK_ALLOC(tmp_email);
 	}
 
 	tmp_name = git__swap(repo->ident_name, tmp_name);
@@ -2924,7 +2869,7 @@ int git_repository_submodule_cache_all(git_repository *repo)
 
 	assert(repo);
 
-	if ((error = git_strmap_new(&repo->submodule_cache)))
+	if ((error = git_strmap_alloc(&repo->submodule_cache)))
 		return error;
 
 	error = git_submodule__map(repo, repo->submodule_cache);