rugged 1.3.1 → 1.9.0

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

@@ -7,11 +7,8 @@
 
 #include "submodule.h"
 
-#include "git2/config.h"
-#include "git2/sys/config.h"
-#include "git2/types.h"
-#include "git2/index.h"
-#include "buffer.h"
+#include "buf.h"
+#include "branch.h"
 #include "vector.h"
 #include "posix.h"
 #include "config_backend.h"
@@ -19,10 +16,17 @@
 #include "repository.h"
 #include "tree.h"
 #include "iterator.h"
-#include "path.h"
+#include "fs_path.h"
+#include "str.h"
 #include "index.h"
 #include "worktree.h"
 #include "clone.h"
+#include "path.h"
+
+#include "git2/config.h"
+#include "git2/sys/config.h"
+#include "git2/types.h"
+#include "git2/index.h"
 
 #define GIT_MODULES_FILE ".gitmodules"
 
@@ -57,14 +61,14 @@ enum {
 };
 enum {
 	GITMODULES_EXISTING = 0,
-	GITMODULES_CREATE = 1,
+	GITMODULES_CREATE = 1
 };
 
 static int submodule_alloc(git_submodule **out, git_repository *repo, const char *name);
 static git_config_backend *open_gitmodules(git_repository *repo, int gitmod);
 static int gitmodules_snapshot(git_config **snap, git_repository *repo);
-static int get_url_base(git_buf *url, git_repository *repo);
-static int lookup_head_remote_key(git_buf *remote_key, git_repository *repo);
+static int get_url_base(git_str *url, git_repository *repo);
+static int lookup_head_remote_key(git_str *remote_key, git_repository *repo);
 static int lookup_default_remote(git_remote **remote, git_repository *repo);
 static int submodule_load_each(const git_config_entry *entry, void *payload);
 static int submodule_read_config(git_submodule *sm, git_config *cfg);
@@ -79,11 +83,11 @@ static int submodule_cmp(const void *a, const void *b)
 	return strcmp(((git_submodule *)a)->name, ((git_submodule *)b)->name);
 }
 
-static int submodule_config_key_trunc_puts(git_buf *key, const char *suffix)
+static int submodule_config_key_trunc_puts(git_str *key, const char *suffix)
 {
-	ssize_t idx = git_buf_rfind(key, '.');
-	git_buf_truncate(key, (size_t)(idx + 1));
-	return git_buf_puts(key, suffix);
+	ssize_t idx = git_str_rfind(key, '.');
+	git_str_truncate(key, (size_t)(idx + 1));
+	return git_str_puts(key, suffix);
 }
 
 /*
@@ -128,7 +132,7 @@ static int is_path_occupied(bool *occupied, git_repository *repo, const char *pa
 {
 	int error = 0;
 	git_index *index;
-	git_buf dir = GIT_BUF_INIT;
+	git_str dir = GIT_STR_INIT;
 	*occupied = false;
 
 	if ((error = git_repository_index__weakptr(&index, repo)) < 0)
@@ -143,10 +147,10 @@ static int is_path_occupied(bool *occupied, git_repository *repo, const char *pa
 		goto out;
 	}
 
-	if ((error = git_buf_sets(&dir, path)) < 0)
+	if ((error = git_str_sets(&dir, path)) < 0)
 		goto out;
 
-	if ((error = git_path_to_dir(&dir)) < 0)
+	if ((error = git_fs_path_to_dir(&dir)) < 0)
 		goto out;
 
 	if ((error = git_index_find_prefix(NULL, index, dir.ptr)) != GIT_ENOTFOUND) {
@@ -161,26 +165,31 @@ static int is_path_occupied(bool *occupied, git_repository *repo, const char *pa
 	error = 0;
 
 out:
-	git_buf_dispose(&dir);
+	git_str_dispose(&dir);
 	return error;
 }
 
+GIT_HASHMAP_STR_SETUP(git_submodule_namemap, char *);
+
 /**
  * Release the name map returned by 'load_submodule_names'.
  */
-static void free_submodule_names(git_strmap *names)
+static void free_submodule_names(git_submodule_namemap *names)
 {
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 	const char *key;
 	char *value;
 
 	if (names == NULL)
 		return;
 
-	git_strmap_foreach(names, key, value, {
-		git__free((char *) key);
+	while (git_submodule_namemap_iterate(&iter, &key, &value, names) == 0) {
+		git__free((char *)key);
 		git__free(value);
-	});
-	git_strmap_free(names);
+	}
+
+	git_submodule_namemap_dispose(names);
+	git__free(names);
 
 	return;
 }
@@ -190,19 +199,22 @@ static void free_submodule_names(git_strmap *names)
  * TODO: for some use-cases, this might need case-folding on a
  * case-insensitive filesystem
  */
-static int load_submodule_names(git_strmap **out, git_repository *repo, git_config *cfg)
+static int load_submodule_names(git_submodule_namemap **out, git_repository *repo, git_config *cfg)
 {
-	const char *key = "submodule\\..*\\.path";
+	const char *key = "^submodule\\..*\\.path$";
+	char *value;
 	git_config_iterator *iter = NULL;
 	git_config_entry *entry;
-	git_buf buf = GIT_BUF_INIT;
-	git_strmap *names;
+	git_str buf = GIT_STR_INIT;
+	git_submodule_namemap *names;
 	int isvalid, error;
 
 	*out = NULL;
 
-	if ((error = git_strmap_new(&names)) < 0)
+	if ((names = git__calloc(1, sizeof(git_submodule_namemap))) == NULL) {
+		error = -1;
 		goto out;
+	}
 
 	if ((error = git_config_iterator_glob_new(&iter, cfg, key)) < 0)
 		goto out;
@@ -212,15 +224,15 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf
 		fdot = strchr(entry->name, '.');
 		ldot = strrchr(entry->name, '.');
 
-		if (git_strmap_exists(names, entry->value)) {
+		if (git_submodule_namemap_contains(names, entry->value)) {
 			git_error_set(GIT_ERROR_SUBMODULE,
 				   "duplicated submodule path '%s'", entry->value);
 			error = -1;
 			goto out;
 		}
 
-		git_buf_clear(&buf);
-		git_buf_put(&buf, fdot + 1, ldot - fdot - 1);
+		git_str_clear(&buf);
+		git_str_put(&buf, fdot + 1, ldot - fdot - 1);
 		isvalid = git_submodule_name_is_valid(repo, buf.ptr, 0);
 		if (isvalid < 0) {
 			error = isvalid;
@@ -229,7 +241,12 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf
 		if (!isvalid)
 			continue;
 
-		if ((error = git_strmap_set(names, git__strdup(entry->value), git_buf_detach(&buf))) < 0) {
+		if ((value = git__strdup(entry->value)) == NULL) {
+			error = -1;
+			goto out;
+		}
+
+		if ((error = git_submodule_namemap_put(names, value, git_str_detach(&buf))) < 0) {
 			git_error_set(GIT_ERROR_NOMEMORY, "error inserting submodule into hash table");
 			error = -1;
 			goto out;
@@ -243,36 +260,48 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf
 
 out:
 	free_submodule_names(names);
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 	git_config_iterator_free(iter);
 	return error;
 }
 
-int git_submodule_cache_init(git_strmap **out, git_repository *repo)
+GIT_HASHMAP_STR_FUNCTIONS(git_submodule_cache, GIT_HASHMAP_INLINE, git_submodule *);
+
+int git_submodule__map(git_submodule_cache *cache, git_repository *repo);
+
+int git_submodule_cache_init(git_submodule_cache **out, git_repository *repo)
 {
+	git_submodule_cache *cache = NULL;
 	int error = 0;
-	git_strmap *cache = NULL;
+
 	GIT_ASSERT_ARG(out);
 	GIT_ASSERT_ARG(repo);
-	if ((error = git_strmap_new(&cache)) < 0)
-		return error;
-	if ((error = git_submodule__map(repo, cache)) < 0) {
+
+	if ((cache = git__calloc(1, sizeof(git_submodule_cache))) == NULL)
+		return -1;
+
+	if ((error = git_submodule__map(cache, repo)) < 0) {
 		git_submodule_cache_free(cache);
 		return error;
 	}
+
 	*out = cache;
 	return error;
 }
 
-int git_submodule_cache_free(git_strmap *cache)
+int git_submodule_cache_free(git_submodule_cache *cache)
 {
 	git_submodule *sm = NULL;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+
 	if (cache == NULL)
 		return 0;
-	git_strmap_foreach_value(cache, sm, {
+
+	while (git_submodule_cache_iterate(&iter, NULL, &sm, cache) == 0)
 		git_submodule_free(sm);
-	});
-	git_strmap_free(cache);
+
+	git_submodule_cache_dispose(cache);
+	git__free(cache);
 	return 0;
 }
 
@@ -288,7 +317,7 @@ int git_submodule__lookup_with_cache(
 	git_submodule **out, /* NULL if user only wants to test existence */
 	git_repository *repo,
 	const char *name,    /* trailing slash is allowed */
-	git_strmap *cache)
+	git_submodule_cache *cache)
 {
 	int error;
 	unsigned int location;
@@ -303,7 +332,7 @@ int git_submodule__lookup_with_cache(
 	}
 
 	if (cache != NULL) {
-		if ((sm = git_strmap_get(cache, name)) != NULL) {
+		if (git_submodule_cache_get(&sm, cache, name) == 0) {
 			if (out) {
 				*out = sm;
 				GIT_REFCOUNT_INC(*out);
@@ -328,11 +357,11 @@ int git_submodule__lookup_with_cache(
 	/* If it's not configured or we're looking by path  */
 	if (location == 0 || location == GIT_SUBMODULE_STATUS_IN_WD) {
 		git_config_backend *mods;
-		const char *pattern = "submodule\\..*\\.path";
-		git_buf path = GIT_BUF_INIT;
+		const char *pattern = "^submodule\\..*\\.path$";
+		git_str path = GIT_STR_INIT;
 		fbp_data data = { NULL, NULL };
 
-		git_buf_puts(&path, name);
+		git_str_puts(&path, name);
 		while (path.ptr[path.size-1] == '/') {
 			path.ptr[--path.size] = '\0';
 		}
@@ -347,14 +376,14 @@ int git_submodule__lookup_with_cache(
 
 		if (error < 0) {
 			git_submodule_free(sm);
-			git_buf_dispose(&path);
+			git_str_dispose(&path);
 			return error;
 		}
 
 		if (data.name) {
 			git__free(sm->name);
 			sm->name = data.name;
-			sm->path = git_buf_detach(&path);
+			sm->path = git_str_detach(&path);
 
 			/* Try to load again with the right name */
 			if ((error = git_submodule_reload(sm, false)) < 0) {
@@ -363,7 +392,7 @@ int git_submodule__lookup_with_cache(
 			}
 		}
 
-		git_buf_dispose(&path);
+		git_str_dispose(&path);
 	}
 
 	if ((error = git_submodule_location(&location, sm)) < 0) {
@@ -378,17 +407,17 @@ int git_submodule__lookup_with_cache(
 
 		/* If it's not configured, we still check if there's a repo at the path */
 		if (git_repository_workdir(repo)) {
-			git_buf path = GIT_BUF_INIT;
-			if (git_buf_join3(&path, '/',
+			git_str path = GIT_STR_INIT;
+			if (git_str_join3(&path, '/',
 			                  git_repository_workdir(repo),
 					  name, DOT_GIT) < 0 ||
-			    git_path_validate_workdir_buf(NULL, &path) < 0)
+			    git_path_validate_str_length(NULL, &path) < 0)
 				return -1;
 
-			if (git_path_exists(path.ptr))
+			if (git_fs_path_exists(path.ptr))
 				error = GIT_EEXISTS;
 
-			git_buf_dispose(&path);
+			git_str_dispose(&path);
 		}
 
 		submodule_set_lookup_error(error, name);
@@ -405,22 +434,22 @@ int git_submodule__lookup_with_cache(
 
 int git_submodule_name_is_valid(git_repository *repo, const char *name, int flags)
 {
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 	int error, isvalid;
 
 	if (flags == 0)
-		flags = GIT_PATH_REJECT_FILESYSTEM_DEFAULTS;
+		flags = GIT_FS_PATH_REJECT_FILESYSTEM_DEFAULTS;
 
 	/* Avoid allocating a new string if we can avoid it */
 	if (strchr(name, '\\') != NULL) {
-		if ((error = git_path_normalize_slashes(&buf, name)) < 0)
+		if ((error = git_fs_path_normalize_slashes(&buf, name)) < 0)
 			return error;
 	} else {
-		git_buf_attach_notowned(&buf, name, strlen(name));
+		git_str_attach_notowned(&buf, name, strlen(name));
 	}
 
-	isvalid =  git_path_validate(repo, buf.ptr, 0, flags);
-	git_buf_dispose(&buf);
+	isvalid = git_path_is_valid(repo, buf.ptr, 0, flags);
+	git_str_dispose(&buf);
 
 	return isvalid;
 }
@@ -430,19 +459,23 @@ static void submodule_free_dup(void *sm)
 	git_submodule_free(sm);
 }
 
-static int submodule_get_or_create(git_submodule **out, git_repository *repo, git_strmap *map, const char *name)
+static int submodule_get_or_create(
+	git_submodule **out,
+	git_repository *repo,
+	git_submodule_cache *cache,
+	const char *name)
 {
 	git_submodule *sm = NULL;
 	int error;
 
-	if ((sm = git_strmap_get(map, name)) != NULL)
+	if (git_submodule_cache_get(&sm, cache, name) == 0)
 		goto done;
 
 	/* if the submodule doesn't exist yet in the map, create it */
 	if ((error = submodule_alloc(&sm, repo, name)) < 0)
 		return error;
 
-	if ((error = git_strmap_set(map, sm->name, sm)) < 0) {
+	if ((error = git_submodule_cache_put(cache, sm->name, sm)) < 0) {
 		git_submodule_free(sm);
 		return error;
 	}
@@ -453,12 +486,15 @@ done:
 	return 0;
 }
 
-static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cfg)
+static int submodules_from_index(
+	git_submodule_cache *cache,
+	git_index *idx,
+	git_config *cfg)
 {
 	int error;
 	git_iterator *i = NULL;
 	const git_index_entry *entry;
-	git_strmap *names;
+	git_submodule_namemap *names;
 
 	if ((error = load_submodule_names(&names, git_index_owner(idx), cfg)))
 		goto done;
@@ -469,7 +505,7 @@ static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cf
 	while (!(error = git_iterator_advance(&entry, i))) {
 		git_submodule *sm;
 
-		if ((sm = git_strmap_get(map, entry->path)) != NULL) {
+		if (git_submodule_cache_get(&sm, cache, entry->path) == 0) {
 			if (S_ISGITLINK(entry->mode))
 				submodule_update_from_index_entry(sm, entry);
 			else
@@ -477,10 +513,10 @@ static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cf
 		} else if (S_ISGITLINK(entry->mode)) {
 			const char *name;
 
-			if ((name = git_strmap_get(names, entry->path)) == NULL)
+			if (git_submodule_namemap_get((char **)&name, names, entry->path) != 0)
 				name = entry->path;
 
-			if (!submodule_get_or_create(&sm, git_index_owner(idx), map, name)) {
+			if (!submodule_get_or_create(&sm, git_index_owner(idx), cache, name)) {
 				submodule_update_from_index_entry(sm, entry);
 				git_submodule_free(sm);
 			}
@@ -497,12 +533,15 @@ done:
 	return error;
 }
 
-static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg)
+static int submodules_from_head(
+	git_submodule_cache *cache,
+	git_tree *head,
+	git_config *cfg)
 {
 	int error;
 	git_iterator *i = NULL;
 	const git_index_entry *entry;
-	git_strmap *names;
+	git_submodule_namemap *names;
 
 	if ((error = load_submodule_names(&names, git_tree_owner(head), cfg)))
 		goto done;
@@ -513,7 +552,7 @@ static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg
 	while (!(error = git_iterator_advance(&entry, i))) {
 		git_submodule *sm;
 
-		if ((sm = git_strmap_get(map, entry->path)) != NULL) {
+		if (git_submodule_cache_get(&sm, cache, entry->path) == 0) {
 			if (S_ISGITLINK(entry->mode))
 				submodule_update_from_head_data(sm, entry->mode, &entry->id);
 			else
@@ -521,10 +560,10 @@ static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg
 		} else if (S_ISGITLINK(entry->mode)) {
 			const char *name;
 
-			if ((name = git_strmap_get(names, entry->path)) == NULL)
+			if (git_submodule_namemap_get((char **)&name, names, entry->path) != 0)
 				name = entry->path;
 
-			if (!submodule_get_or_create(&sm, git_tree_owner(head), map, name)) {
+			if (!submodule_get_or_create(&sm, git_tree_owner(head), cache, name)) {
 				submodule_update_from_head_data(
 					sm, entry->mode, &entry->id);
 				git_submodule_free(sm);
@@ -545,22 +584,22 @@ done:
 /* If have_sm is true, sm is populated, otherwise map an repo are. */
 typedef struct {
 	git_config *mods;
-	git_strmap *map;
+	git_submodule_cache *cache;
 	git_repository *repo;
 } lfc_data;
 
-int git_submodule__map(git_repository *repo, git_strmap *map)
+int git_submodule__map(git_submodule_cache *cache, git_repository *repo)
 {
 	int error = 0;
 	git_index *idx = NULL;
 	git_tree *head = NULL;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	git_submodule *sm;
 	git_config *mods = NULL;
 	bool has_workdir;
 
+	GIT_ASSERT_ARG(cache);
 	GIT_ASSERT_ARG(repo);
-	GIT_ASSERT_ARG(map);
 
 	/* get sources that we will need to check */
 	if (git_repository_index(&idx, repo) < 0)
@@ -577,7 +616,7 @@ int git_submodule__map(git_repository *repo, git_strmap *map)
 	/* add submodule information from .gitmodules */
 	if (has_workdir) {
 		lfc_data data = { 0 };
-		data.map = map;
+		data.cache = cache;
 		data.repo = repo;
 
 		if ((error = gitmodules_snapshot(&mods, repo)) < 0) {
@@ -593,19 +632,22 @@ int git_submodule__map(git_repository *repo, git_strmap *map)
 	}
 	/* add back submodule information from index */
 	if (mods && idx) {
-		if ((error = submodules_from_index(map, idx, mods)) < 0)
+		if ((error = submodules_from_index(cache, idx, mods)) < 0)
 			goto cleanup;
 	}
 	/* add submodule information from HEAD */
 	if (mods && head) {
-		if ((error = submodules_from_head(map, head, mods)) < 0)
+		if ((error = submodules_from_head(cache, head, mods)) < 0)
 			goto cleanup;
 	}
 	/* shallow scan submodules in work tree as needed */
 	if (has_workdir) {
-		git_strmap_foreach_value(map, sm, {
-				submodule_load_from_wd_lite(sm);
-			});
+		git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+
+		while (git_submodule_cache_iterate(&iter, NULL, &sm, cache) == 0) {
+			if ((error = submodule_load_from_wd_lite(sm)) < 0)
+				goto cleanup;
+		}
 	}
 
 cleanup:
@@ -613,7 +655,7 @@ cleanup:
 	/* TODO: if we got an error, mark submodule config as invalid? */
 	git_index_free(idx);
 	git_tree_free(head);
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	return error;
 }
 
@@ -623,8 +665,9 @@ int git_submodule_foreach(
 	void *payload)
 {
 	git_vector snapshot = GIT_VECTOR_INIT;
-	git_strmap *submodules;
+	git_submodule_cache *submodules;
 	git_submodule *sm;
+	git_hashmap_iter_t iter;
 	int error;
 	size_t i;
 
@@ -633,20 +676,22 @@ int git_submodule_foreach(
 		return -1;
 	}
 
-	if ((error = git_strmap_new(&submodules)) < 0)
-		return error;
+	if ((submodules = git__calloc(1, sizeof(git_submodule_cache))) == NULL)
+		return -1;
 
-	if ((error = git_submodule__map(repo, submodules)) < 0)
+	if ((error = git_submodule__map(submodules, repo)) < 0)
 		goto done;
 
-	if (!(error = git_vector_init(
-			&snapshot, git_strmap_size(submodules), submodule_cmp))) {
-
-		git_strmap_foreach_value(submodules, sm, {
+	if (!(error = git_vector_init(&snapshot,
+			git_submodule_cache_size(submodules),
+			submodule_cmp))) {
+		for (iter = GIT_HASHMAP_ITER_INIT;
+		     git_submodule_cache_iterate(&iter, NULL, &sm, submodules) == 0; ) {
 			if ((error = git_vector_insert(&snapshot, sm)) < 0)
 				break;
+
 			GIT_REFCOUNT_INC(sm);
-		});
+		}
 	}
 
 	if (error < 0)
@@ -664,12 +709,14 @@ int git_submodule_foreach(
 done:
 	git_vector_foreach(&snapshot, i, sm)
 		git_submodule_free(sm);
-	git_vector_free(&snapshot);
+	git_vector_dispose(&snapshot);
 
-	git_strmap_foreach_value(submodules, sm, {
+	for (iter = GIT_HASHMAP_ITER_INIT;
+	     git_submodule_cache_iterate(&iter, NULL, &sm, submodules) == 0; )
 		git_submodule_free(sm);
-	});
-	git_strmap_free(submodules);
+
+	git_submodule_cache_dispose(submodules);
+	git__free(submodules);
 
 	return error;
 }
@@ -682,7 +729,7 @@ static int submodule_repo_init(
 	bool use_gitlink)
 {
 	int error = 0;
-	git_buf workdir = GIT_BUF_INIT, repodir = GIT_BUF_INIT;
+	git_str workdir = GIT_STR_INIT, repodir = GIT_STR_INIT;
 	git_repository_init_options initopt = GIT_REPOSITORY_INIT_OPTIONS_INIT;
 	git_repository *subrepo = NULL;
 
@@ -701,10 +748,10 @@ static int submodule_repo_init(
 	 * Old style: sub-repo goes directly into repo/<name>/.git/
 	 */
 	 if (use_gitlink) {
-		error = git_repository_item_path(&repodir, parent_repo, GIT_REPOSITORY_ITEM_MODULES);
+		error = git_repository__item_path(&repodir, parent_repo, GIT_REPOSITORY_ITEM_MODULES);
 		if (error < 0)
 			goto cleanup;
-		error = git_buf_joinpath(&repodir, repodir.ptr, path);
+		error = git_str_joinpath(&repodir, repodir.ptr, path);
 		if (error < 0)
 			goto cleanup;
 
@@ -718,14 +765,57 @@ static int submodule_repo_init(
 		error = git_repository_init_ext(&subrepo, workdir.ptr, &initopt);
 
 cleanup:
-	git_buf_dispose(&workdir);
-	git_buf_dispose(&repodir);
+	git_str_dispose(&workdir);
+	git_str_dispose(&repodir);
 
 	*out = subrepo;
 
 	return error;
 }
 
+static int git_submodule__resolve_url(
+	git_str *out,
+	git_repository *repo,
+	const char *url)
+{
+	int error = 0;
+	git_str normalized = GIT_STR_INIT;
+
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(url);
+
+	/* We do this in all platforms in case someone on Windows created the .gitmodules */
+	if (strchr(url, '\\')) {
+		if ((error = git_fs_path_normalize_slashes(&normalized, url)) < 0)
+			return error;
+
+		url = normalized.ptr;
+	}
+
+
+	if (git_fs_path_is_relative(url)) {
+		if (!(error = get_url_base(out, repo)))
+			error = git_fs_path_apply_relative(out, url);
+	} else if (strchr(url, ':') != NULL || url[0] == '/') {
+		error = git_str_sets(out, url);
+	} else {
+		git_error_set(GIT_ERROR_SUBMODULE, "invalid format for submodule URL");
+		error = -1;
+	}
+
+	git_str_dispose(&normalized);
+	return error;
+}
+
+int git_submodule_resolve_url(
+	git_buf *out,
+	git_repository *repo,
+	const char *url)
+{
+	GIT_BUF_WRAP_PRIVATE(out, git_submodule__resolve_url, repo, url);
+}
+
 int git_submodule_add_setup(
 	git_submodule **out,
 	git_repository *repo,
@@ -736,7 +826,7 @@ int git_submodule_add_setup(
 	int error = 0;
 	git_config_backend *mods = NULL;
 	git_submodule *sm = NULL;
-	git_buf name = GIT_BUF_INIT, real_url = GIT_BUF_INIT;
+	git_str name = GIT_STR_INIT, real_url = GIT_STR_INIT;
 	git_repository *subrepo = NULL;
 	bool path_occupied;
 
@@ -759,7 +849,7 @@ int git_submodule_add_setup(
 	if (git__prefixcmp(path, git_repository_workdir(repo)) == 0)
 		path += strlen(git_repository_workdir(repo));
 
-	if (git_path_root(path) >= 0) {
+	if (git_fs_path_root(path) >= 0) {
 		git_error_set(GIT_ERROR_SUBMODULE, "submodule path must be a relative path");
 		error = -1;
 		goto cleanup;
@@ -781,7 +871,7 @@ int git_submodule_add_setup(
 		return -1;
 	}
 
-	if ((error = git_buf_printf(&name, "submodule.%s.path", path)) < 0 ||
+	if ((error = git_str_printf(&name, "submodule.%s.path", path)) < 0 ||
 		(error = git_config_backend_set_string(mods, name.ptr, path)) < 0)
 		goto cleanup;
 
@@ -789,7 +879,7 @@ int git_submodule_add_setup(
 		(error = git_config_backend_set_string(mods, name.ptr, url)) < 0)
 		goto cleanup;
 
-	git_buf_clear(&name);
+	git_str_clear(&name);
 
 	/* init submodule repository and add origin remote as needed */
 
@@ -800,11 +890,11 @@ int git_submodule_add_setup(
 	/* if the repo does not already exist, then init a new repo and add it.
 	 * Otherwise, just add the existing repo.
 	 */
-	if (!(git_path_exists(name.ptr) &&
-		git_path_contains(&name, DOT_GIT))) {
+	if (!(git_fs_path_exists(name.ptr) &&
+		git_fs_path_contains(&name, DOT_GIT))) {
 
 		/* resolve the actual URL to use */
-		if ((error = git_submodule_resolve_url(&real_url, repo, url)) < 0)
+		if ((error = git_submodule__resolve_url(&real_url, repo, url)) < 0)
 			goto cleanup;
 
 		 if ((error = submodule_repo_init(&subrepo, repo, path, real_url.ptr, use_gitlink)) < 0)
@@ -826,8 +916,8 @@ cleanup:
 
 	git_config_backend_free(mods);
 	git_repository_free(subrepo);
-	git_buf_dispose(&real_url);
-	git_buf_dispose(&name);
+	git_str_dispose(&real_url);
+	git_str_dispose(&name);
 
 	return error;
 }
@@ -841,13 +931,13 @@ int git_submodule_repo_init(
 	git_repository *sub_repo = NULL;
 	const char *configured_url;
 	git_config *cfg = NULL;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 
 	GIT_ASSERT_ARG(out);
 	GIT_ASSERT_ARG(sm);
 
 	/* get the configured remote url of the submodule */
-	if ((error = git_buf_printf(&buf, "submodule.%s.url", sm->name)) < 0 ||
+	if ((error = git_str_printf(&buf, "submodule.%s.url", sm->name)) < 0 ||
 		(error = git_repository_config_snapshot(&cfg, sm->repo)) < 0 ||
 		(error = git_config_get_string(&configured_url, cfg, buf.ptr)) < 0 ||
 		(error = submodule_repo_init(&sub_repo, sm->repo, sm->path, configured_url, use_gitlink)) < 0)
@@ -857,7 +947,7 @@ int git_submodule_repo_init(
 
 done:
 	git_config_free(cfg);
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 	return error;
 }
 
@@ -881,7 +971,7 @@ int git_submodule_clone(git_repository **out, git_submodule *submodule, const gi
 {
 	int error;
 	git_repository *clone;
-	git_buf rel_path = GIT_BUF_INIT;
+	git_str rel_path = GIT_STR_INIT;
 	git_submodule_update_options sub_opts = GIT_SUBMODULE_UPDATE_OPTIONS_INIT;
 	git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
 
@@ -903,7 +993,7 @@ int git_submodule_clone(git_repository **out, git_submodule *submodule, const gi
 	if (error < 0)
 		goto cleanup;
 
-	error = git_clone__submodule(&clone, git_submodule_url(submodule), git_buf_cstr(&rel_path), &opts);
+	error = git_clone__submodule(&clone, git_submodule_url(submodule), git_str_cstr(&rel_path), &opts);
 	if (error < 0)
 		goto cleanup;
 
@@ -913,7 +1003,7 @@ int git_submodule_clone(git_repository **out, git_submodule *submodule, const gi
 		*out = clone;
 
 cleanup:
-	git_buf_dispose(&rel_path);
+	git_str_dispose(&rel_path);
 
 	return error;
 }
@@ -937,7 +1027,7 @@ int git_submodule_add_to_index(git_submodule *sm, int write_index)
 	int error;
 	git_repository *sm_repo = NULL;
 	git_index *index;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	git_commit *head;
 	git_index_entry entry;
 	struct stat st;
@@ -997,7 +1087,7 @@ int git_submodule_add_to_index(git_submodule *sm, int write_index)
 
 cleanup:
 	git_repository_free(sm_repo);
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	return error;
 }
 
@@ -1034,44 +1124,9 @@ const char *git_submodule_url(git_submodule *submodule)
 	return submodule->url;
 }
 
-int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *url)
-{
-	int error = 0;
-	git_buf normalized = GIT_BUF_INIT;
-
-	GIT_ASSERT_ARG(out);
-	GIT_ASSERT_ARG(repo);
-	GIT_ASSERT_ARG(url);
-
-	if ((error = git_buf_sanitize(out)) < 0)
-		return error;
-
-	/* We do this in all platforms in case someone on Windows created the .gitmodules */
-	if (strchr(url, '\\')) {
-		if ((error = git_path_normalize_slashes(&normalized, url)) < 0)
-			return error;
-
-		url = normalized.ptr;
-	}
-
-
-	if (git_path_is_relative(url)) {
-		if (!(error = get_url_base(out, repo)))
-			error = git_path_apply_relative(out, url);
-	} else if (strchr(url, ':') != NULL || url[0] == '/') {
-		error = git_buf_sets(out, url);
-	} else {
-		git_error_set(GIT_ERROR_SUBMODULE, "invalid format for submodule URL");
-		error = -1;
-	}
-
-	git_buf_dispose(&normalized);
-	return error;
-}
-
 static int write_var(git_repository *repo, const char *name, const char *var, const char *val)
 {
-	git_buf key = GIT_BUF_INIT;
+	git_str key = GIT_STR_INIT;
 	git_config_backend *mods;
 	int error;
 
@@ -1079,7 +1134,7 @@ static int write_var(git_repository *repo, const char *name, const char *var, co
 	if (!mods)
 		return -1;
 
-	if ((error = git_buf_printf(&key, "submodule.%s.%s", name, var)) < 0)
+	if ((error = git_str_printf(&key, "submodule.%s.%s", name, var)) < 0)
 		goto cleanup;
 
 	if (val)
@@ -1087,7 +1142,7 @@ static int write_var(git_repository *repo, const char *name, const char *var, co
 	else
 		error = git_config_backend_delete(mods, key.ptr);
 
-	git_buf_dispose(&key);
+	git_str_dispose(&key);
 
 cleanup:
 	git_config_backend_free(mods);
@@ -1227,7 +1282,7 @@ static int submodule_repo_create(
 	const char *path)
 {
 	int error = 0;
-	git_buf workdir = GIT_BUF_INIT, repodir = GIT_BUF_INIT;
+	git_str workdir = GIT_STR_INIT, repodir = GIT_STR_INIT;
 	git_repository_init_options initopt = GIT_REPOSITORY_INIT_OPTIONS_INIT;
 	git_repository *subrepo = NULL;
 
@@ -1249,18 +1304,18 @@ static int submodule_repo_create(
 	 * <repo-dir>/modules/<name>/ with a gitlink in the
 	 * sub-repo workdir directory to that repository.
 	 */
-	error = git_repository_item_path(&repodir, parent_repo, GIT_REPOSITORY_ITEM_MODULES);
+	error = git_repository__item_path(&repodir, parent_repo, GIT_REPOSITORY_ITEM_MODULES);
 	if (error < 0)
 		goto cleanup;
-	error = git_buf_joinpath(&repodir, repodir.ptr, path);
+	error = git_str_joinpath(&repodir, repodir.ptr, path);
 	if (error < 0)
 		goto cleanup;
 
 	error = git_repository_init_ext(&subrepo, repodir.ptr, &initopt);
 
 cleanup:
-	git_buf_dispose(&workdir);
-	git_buf_dispose(&repodir);
+	git_str_dispose(&workdir);
+	git_str_dispose(&repodir);
 
 	*out = subrepo;
 
@@ -1309,7 +1364,7 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
 	git_repository *sub_repo = NULL;
 	git_remote *remote = NULL;
 	git_object *target_commit = NULL;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 	git_submodule_update_options update_options = GIT_SUBMODULE_UPDATE_OPTIONS_INIT;
 	git_clone_options clone_options = GIT_CLONE_OPTIONS_INIT;
 
@@ -1327,6 +1382,10 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
 	if ((error = git_submodule_status(&submodule_status, sm->repo, sm->name, GIT_SUBMODULE_IGNORE_UNSPECIFIED)) < 0)
 		goto done;
 
+	/* If the submodule is configured but hasn't been added, skip it */
+	if (submodule_status == GIT_SUBMODULE_STATUS_IN_CONFIG)
+	        goto done;
+
 	/*
 	 * If submodule work dir is not already initialized, check to see
 	 * what we need to do (initialize, clone, return error...)
@@ -1337,10 +1396,10 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
 		 * info has been copied into .git/config
 		 */
 		if ((error = git_repository_config_snapshot(&config, sm->repo)) < 0 ||
-			(error = git_buf_printf(&buf, "submodule.%s.url", git_submodule_name(sm))) < 0)
+			(error = git_str_printf(&buf, "submodule.%s.url", git_submodule_name(sm))) < 0)
 			goto done;
 
-		if ((error = git_config_get_string(&submodule_url, config, git_buf_cstr(&buf))) < 0) {
+		if ((error = git_config_get_string(&submodule_url, config, git_str_cstr(&buf))) < 0) {
 			/*
 			 * If the error is not "not found" or if it is "not found" and we are not
 			 * initializing the submodule, then return error.
@@ -1362,7 +1421,7 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
 			config = NULL;
 
 			if ((error = git_repository_config_snapshot(&config, sm->repo)) < 0 ||
-				(error = git_config_get_string(&submodule_url, config, git_buf_cstr(&buf))) < 0)
+				(error = git_config_get_string(&submodule_url, config, git_str_cstr(&buf))) < 0)
 				goto done;
 		}
 
@@ -1377,7 +1436,7 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
 		 */
 		clone_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_NONE;
 
-		if ((error = git_clone(&sub_repo, submodule_url, sm->path, &clone_options)) < 0 ||
+		if ((error = git_clone__submodule(&sub_repo, submodule_url, sm->path, &clone_options)) < 0 ||
 			(error = git_repository_set_head_detached(sub_repo, git_submodule_index_id(sm))) < 0 ||
 			(error = git_checkout_head(sub_repo, &update_options.checkout_opts)) != 0)
 			goto done;
@@ -1420,7 +1479,7 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
 	}
 
 done:
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 	git_config_free(config);
 	git_object_free(target_commit);
 	git_remote_free(remote);
@@ -1433,7 +1492,7 @@ int git_submodule_init(git_submodule *sm, int overwrite)
 {
 	int error;
 	const char *val;
-	git_buf key = GIT_BUF_INIT, effective_submodule_url = GIT_BUF_INIT;
+	git_str key = GIT_STR_INIT, effective_submodule_url = GIT_STR_INIT;
 	git_config *cfg = NULL;
 
 	if (!sm->url) {
@@ -1447,8 +1506,8 @@ int git_submodule_init(git_submodule *sm, int overwrite)
 
 	/* write "submodule.NAME.url" */
 
-	if ((error = git_submodule_resolve_url(&effective_submodule_url, sm->repo, sm->url)) < 0 ||
-		(error = git_buf_printf(&key, "submodule.%s.url", sm->name)) < 0 ||
+	if ((error = git_submodule__resolve_url(&effective_submodule_url, sm->repo, sm->url)) < 0 ||
+		(error = git_str_printf(&key, "submodule.%s.url", sm->name)) < 0 ||
 		(error = git_config__update_entry(
 			cfg, key.ptr, effective_submodule_url.ptr, overwrite != 0, false)) < 0)
 		goto cleanup;
@@ -1458,7 +1517,7 @@ int git_submodule_init(git_submodule *sm, int overwrite)
 	val = (sm->update == GIT_SUBMODULE_UPDATE_CHECKOUT) ?
 		NULL : submodule_update_to_str(sm->update);
 
-	if ((error = git_buf_printf(&key, "submodule.%s.update", sm->name)) < 0 ||
+	if ((error = git_str_printf(&key, "submodule.%s.update", sm->name)) < 0 ||
 		(error = git_config__update_entry(
 			cfg, key.ptr, val, overwrite != 0, false)) < 0)
 		goto cleanup;
@@ -1467,15 +1526,15 @@ int git_submodule_init(git_submodule *sm, int overwrite)
 
 cleanup:
 	git_config_free(cfg);
-	git_buf_dispose(&key);
-	git_buf_dispose(&effective_submodule_url);
+	git_str_dispose(&key);
+	git_str_dispose(&effective_submodule_url);
 
 	return error;
 }
 
 int git_submodule_sync(git_submodule *sm)
 {
-	git_buf key = GIT_BUF_INIT, url = GIT_BUF_INIT, remote_name = GIT_BUF_INIT;
+	git_str key = GIT_STR_INIT, url = GIT_STR_INIT, remote_name = GIT_STR_INIT;
 	git_repository *smrepo = NULL;
 	git_config *cfg = NULL;
 	int error = 0;
@@ -1487,8 +1546,8 @@ int git_submodule_sync(git_submodule *sm)
 
 	/* copy URL over to config only if it already exists */
 	if ((error = git_repository_config__weakptr(&cfg, sm->repo)) < 0 ||
-	    (error = git_buf_printf(&key, "submodule.%s.url", sm->name)) < 0 ||
-	    (error = git_submodule_resolve_url(&url, sm->repo, sm->url)) < 0 ||
+	    (error = git_str_printf(&key, "submodule.%s.url", sm->name)) < 0 ||
+	    (error = git_submodule__resolve_url(&url, sm->repo, sm->url)) < 0 ||
 	    (error = git_config__update_entry(cfg, key.ptr, url.ptr, true, true)) < 0)
 		goto out;
 
@@ -1501,9 +1560,9 @@ int git_submodule_sync(git_submodule *sm)
 		goto out;
 
 	if (lookup_head_remote_key(&remote_name, smrepo) == 0) {
-		if ((error = git_buf_join3(&key, '.', "remote", remote_name.ptr, "url")) < 0)
+		if ((error = git_str_join3(&key, '.', "remote", remote_name.ptr, "url")) < 0)
 			goto out;
-	} else if ((error = git_buf_sets(&key, "remote.origin.url")) < 0) {
+	} else if ((error = git_str_sets(&key, "remote.origin.url")) < 0) {
 		goto out;
 	}
 
@@ -1512,9 +1571,9 @@ int git_submodule_sync(git_submodule *sm)
 
 out:
 	git_repository_free(smrepo);
-	git_buf_dispose(&remote_name);
-	git_buf_dispose(&key);
-	git_buf_dispose(&url);
+	git_str_dispose(&remote_name);
+	git_str_dispose(&key);
+	git_str_dispose(&url);
 	return error;
 }
 
@@ -1522,7 +1581,7 @@ static int git_submodule__open(
 	git_repository **subrepo, git_submodule *sm, bool bare)
 {
 	int error;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	unsigned int flags = GIT_REPOSITORY_OPEN_NO_SEARCH;
 	const char *wd;
 
@@ -1535,7 +1594,7 @@ static int git_submodule__open(
 
 	wd = git_repository_workdir(sm->repo);
 
-	if (git_buf_join3(&path, '/', wd, sm->path, DOT_GIT) < 0)
+	if (git_str_join3(&path, '/', wd, sm->path, DOT_GIT) < 0)
 		return -1;
 
 	sm->flags = sm->flags &
@@ -1557,17 +1616,17 @@ static int git_submodule__open(
 			sm->flags |= GIT_SUBMODULE_STATUS__WD_OID_VALID;
 		else
 			git_error_clear();
-	} else if (git_path_exists(path.ptr)) {
+	} else if (git_fs_path_exists(path.ptr)) {
 		sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED |
 			GIT_SUBMODULE_STATUS_IN_WD;
 	} else {
-		git_buf_rtruncate_at_char(&path, '/'); /* remove "/.git" */
+		git_str_rtruncate_at_char(&path, '/'); /* remove "/.git" */
 
-		if (git_path_isdir(path.ptr))
+		if (git_fs_path_isdir(path.ptr))
 			sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED;
 	}
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 
 	return error;
 }
@@ -1921,13 +1980,13 @@ static int submodule_parse_recurse(git_submodule_recurse_t *out, const char *val
 	return 0;
 }
 
-static int get_value(const char **out, git_config *cfg, git_buf *buf, const char *name, const char *field)
+static int get_value(const char **out, git_config *cfg, git_str *buf, const char *name, const char *field)
 {
 	int error;
 
-	git_buf_clear(buf);
+	git_str_clear(buf);
 
-	if ((error = git_buf_printf(buf, "submodule.%s.%s", name, field)) < 0 ||
+	if ((error = git_str_printf(buf, "submodule.%s.%s", name, field)) < 0 ||
 	    (error = git_config_get_string(out, cfg, buf->ptr)) < 0)
 		return error;
 
@@ -1944,7 +2003,7 @@ static bool looks_like_command_line_option(const char *s)
 
 static int submodule_read_config(git_submodule *sm, git_config *cfg)
 {
-	git_buf key = GIT_BUF_INIT;
+	git_str key = GIT_STR_INIT;
 	const char *value;
 	int error, in_config = 0;
 
@@ -2025,7 +2084,7 @@ static int submodule_read_config(git_submodule *sm, git_config *cfg)
 	error = 0;
 
 cleanup:
-	git_buf_dispose(&key);
+	git_str_dispose(&key);
 	return error;
 }
 
@@ -2033,8 +2092,8 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 {
 	lfc_data *data = payload;
 	const char *namestart, *property;
-	git_strmap *map = data->map;
-	git_buf name = GIT_BUF_INIT;
+	git_submodule_cache *cache = data->cache;
+	git_str name = GIT_STR_INIT;
 	git_submodule *sm;
 	int error, isvalid;
 
@@ -2049,7 +2108,7 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 
 	property++;
 
-	if ((error = git_buf_set(&name, namestart, property - namestart -1)) < 0)
+	if ((error = git_str_set(&name, namestart, property - namestart -1)) < 0)
 		return error;
 
 	isvalid = git_submodule_name_is_valid(data->repo, name.ptr, 0);
@@ -2064,7 +2123,7 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 	 * a new submodule, load the config and insert it. If it's
 	 * already inserted, we've already loaded it, so we skip.
 	 */
-	if (git_strmap_exists(map, name.ptr)) {
+	if (git_submodule_cache_contains(cache, name.ptr)) {
 		error = 0;
 		goto done;
 	}
@@ -2077,30 +2136,30 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 		goto done;
 	}
 
-	if ((error = git_strmap_set(map, sm->name, sm)) < 0)
+	if ((error = git_submodule_cache_put(cache, sm->name, sm)) < 0)
 		goto done;
 
 	error = 0;
 
 done:
-	git_buf_dispose(&name);
+	git_str_dispose(&name);
 	return error;
 }
 
 static int submodule_load_from_wd_lite(git_submodule *sm)
 {
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 
 	if (git_repository_workdir_path(&path, sm->repo, sm->path) < 0)
 		return -1;
 
-	if (git_path_isdir(path.ptr))
+	if (git_fs_path_isdir(path.ptr))
 		sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED;
 
-	if (git_path_contains(&path, DOT_GIT))
+	if (git_fs_path_contains(&path, DOT_GIT))
 		sm->flags |= GIT_SUBMODULE_STATUS_IN_WD;
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	return 0;
 }
 
@@ -2112,7 +2171,7 @@ static int submodule_load_from_wd_lite(git_submodule *sm)
 static int gitmodules_snapshot(git_config **snap, git_repository *repo)
 {
 	git_config *mods = NULL;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	int error;
 
 	if (git_repository_workdir(repo) == NULL)
@@ -2123,7 +2182,7 @@ static int gitmodules_snapshot(git_config **snap, git_repository *repo)
 
 	if ((error = git_config_open_ondisk(&mods, path.ptr)) < 0)
 		goto cleanup;
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 
 	if ((error = git_config_snapshot(snap, mods)) < 0)
 		goto cleanup;
@@ -2133,7 +2192,7 @@ static int gitmodules_snapshot(git_config **snap, git_repository *repo)
 cleanup:
 	if (mods)
 		git_config_free(mods);
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 
 	return error;
 }
@@ -2142,14 +2201,14 @@ static git_config_backend *open_gitmodules(
 	git_repository *repo,
 	int okay_to_create)
 {
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	git_config_backend *mods = NULL;
 
 	if (git_repository_workdir(repo) != NULL) {
 		if (git_repository_workdir_path(&path, repo, GIT_MODULES_FILE) != 0)
 			return NULL;
 
-		if (okay_to_create || git_path_isfile(path.ptr)) {
+		if (okay_to_create || git_fs_path_isfile(path.ptr)) {
 			/* git_config_backend_from_file should only fail if OOM */
 			if (git_config_backend_from_file(&mods, path.ptr) < 0)
 				mods = NULL;
@@ -2161,17 +2220,17 @@ static git_config_backend *open_gitmodules(
 		}
 	}
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 
 	return mods;
 }
 
 /* Lookup name of remote of the local tracking branch HEAD points to */
-static int lookup_head_remote_key(git_buf *remote_name, git_repository *repo)
+static int lookup_head_remote_key(git_str *remote_name, git_repository *repo)
 {
 	int error;
 	git_reference *head = NULL;
-	git_buf upstream_name = GIT_BUF_INIT;
+	git_str upstream_name = GIT_STR_INIT;
 
 	/* lookup and dereference HEAD */
 	if ((error = git_repository_head(&head, repo)) < 0)
@@ -2190,18 +2249,18 @@ static int lookup_head_remote_key(git_buf *remote_name, git_repository *repo)
 	}
 
 	/* lookup remote tracking branch of HEAD */
-	if ((error = git_branch_upstream_name(
+	if ((error = git_branch__upstream_name(
 		&upstream_name,
 		repo,
 		git_reference_name(head))) < 0)
 		goto done;
 
 	/* lookup remote of remote tracking branch */
-	if ((error = git_branch_remote_name(remote_name, repo, upstream_name.ptr)) < 0)
+	if ((error = git_branch__remote_name(remote_name, repo, upstream_name.ptr)) < 0)
 		goto done;
 
 done:
-	git_buf_dispose(&upstream_name);
+	git_str_dispose(&upstream_name);
 	git_reference_free(head);
 
 	return error;
@@ -2211,13 +2270,13 @@ done:
 static int lookup_head_remote(git_remote **remote, git_repository *repo)
 {
 	int error;
-	git_buf remote_name = GIT_BUF_INIT;
+	git_str remote_name = GIT_STR_INIT;
 
 	/* lookup remote of remote tracking branch name */
 	if (!(error = lookup_head_remote_key(&remote_name, repo)))
 		error = git_remote_lookup(remote, repo, remote_name.ptr);
 
-	git_buf_dispose(&remote_name);
+	git_str_dispose(&remote_name);
 
 	return error;
 }
@@ -2240,14 +2299,14 @@ static int lookup_default_remote(git_remote **remote, git_repository *repo)
 	return error;
 }
 
-static int get_url_base(git_buf *url, git_repository *repo)
+static int get_url_base(git_str *url, git_repository *repo)
 {
 	int error;
 	git_worktree *wt = NULL;
 	git_remote *remote = NULL;
 
 	if ((error = lookup_default_remote(&remote, repo)) == 0) {
-		error = git_buf_sets(url, git_remote_url(remote));
+		error = git_str_sets(url, git_remote_url(remote));
 		goto out;
 	} else if (error != GIT_ENOTFOUND)
 		goto out;
@@ -2258,9 +2317,9 @@ static int get_url_base(git_buf *url, git_repository *repo)
 	if (git_repository_is_worktree(repo)) {
 		if ((error = git_worktree_open_from_repository(&wt, repo)) < 0)
 			goto out;
-		error = git_buf_sets(url, wt->parent_path);
+		error = git_str_sets(url, wt->parent_path);
 	} else {
-		error = git_buf_sets(url, git_repository_workdir(repo));
+		error = git_str_sets(url, git_repository_workdir(repo));
 	}
 
 out: