str: introduce `git_str` for internal, `git_buf` is externalethomson/gitstr

libgit2 has two distinct requirements that were previously solved by
`git_buf`.  We require:

1. A general purpose string class that provides a number of utility APIs
   for manipulating data (eg, concatenating, truncating, etc).
2. A structure that we can use to return strings to callers that they
   can take ownership of.

By using a single class (`git_buf`) for both of these purposes, we have
confused the API to the point that refactorings are difficult and
reasoning about correctness is also difficult.

Move the utility class `git_buf` to be called `git_str`: this represents
its general purpose, as an internal string buffer class.  The name also
is an homage to Junio Hamano ("gitstr").

The public API remains `git_buf`, and has a much smaller footprint.  It
is generally only used as an "out" param with strict requirements that
follow the documentation.  (Exceptions exist for some legacy APIs to
avoid breaking callers unnecessarily.)

Utility functions exist to convert a user-specified `git_buf` to a
`git_str` so that we can call internal functions, then converting it
back again.

1 files changed, 51 insertions, 51 deletions

diff --git a/tests/worktree/worktree.c b/tests/worktree/worktree.c
index 9b87bfae6..a9a50fbf1 100644
--- a/tests/worktree/worktree.c
+++ b/tests/worktree/worktree.c
@@ -40,11 +40,11 @@ void test_worktree_worktree__list_with_invalid_worktree_dirs(void)
 		{ "gitdir", "HEAD" },
 		{ "HEAD", "commondir" },
 	};
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	git_strarray wts;
 	size_t i, j, len;
 
-	cl_git_pass(git_buf_joinpath(&path,
+	cl_git_pass(git_str_joinpath(&path,
 	            fixture.repo->commondir,
 	            "worktrees/invalid"));
 	cl_git_pass(p_mkdir(path.ptr, 0755));
@@ -54,8 +54,8 @@ void test_worktree_worktree__list_with_invalid_worktree_dirs(void)
 	for (i = 0; i < ARRAY_SIZE(filesets); i++) {
 
 		for (j = 0; j < ARRAY_SIZE(filesets[i]); j++) {
-			git_buf_truncate(&path, len);
-			cl_git_pass(git_buf_joinpath(&path, path.ptr, filesets[i][j]));
+			git_str_truncate(&path, len);
+			cl_git_pass(git_str_joinpath(&path, path.ptr, filesets[i][j]));
 			cl_git_pass(p_close(p_creat(path.ptr, 0644)));
 		}
 
@@ -65,13 +65,13 @@ void test_worktree_worktree__list_with_invalid_worktree_dirs(void)
 		git_strarray_dispose(&wts);
 
 		for (j = 0; j < ARRAY_SIZE(filesets[i]); j++) {
-			git_buf_truncate(&path, len);
-			cl_git_pass(git_buf_joinpath(&path, path.ptr, filesets[i][j]));
+			git_str_truncate(&path, len);
+			cl_git_pass(git_str_joinpath(&path, path.ptr, filesets[i][j]));
 			p_unlink(path.ptr);
 		}
 	}
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 }
 
 void test_worktree_worktree__list_in_worktree_repo(void)
@@ -100,11 +100,11 @@ void test_worktree_worktree__list_without_worktrees(void)
 void test_worktree_worktree__lookup(void)
 {
 	git_worktree *wt;
-	git_buf gitdir_path = GIT_BUF_INIT;
+	git_str gitdir_path = GIT_STR_INIT;
 
 	cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree"));
 
-	cl_git_pass(git_buf_joinpath(&gitdir_path, fixture.repo->commondir, "worktrees/testrepo-worktree/"));
+	cl_git_pass(git_str_joinpath(&gitdir_path, fixture.repo->commondir, "worktrees/testrepo-worktree/"));
 
 	cl_assert_equal_s(wt->gitdir_path, gitdir_path.ptr);
 	cl_assert_equal_s(wt->parent_path, fixture.repo->workdir);
@@ -112,7 +112,7 @@ void test_worktree_worktree__lookup(void)
 	cl_assert_equal_s(wt->commondir_path, fixture.repo->gitdir);
 	cl_assert_equal_s(wt->commondir_path, fixture.repo->commondir);
 
-	git_buf_dispose(&gitdir_path);
+	git_str_dispose(&gitdir_path);
 	git_worktree_free(wt);
 }
 
@@ -143,10 +143,10 @@ void test_worktree_worktree__open_invalid_commondir(void)
 {
 	git_worktree *wt;
 	git_repository *repo;
-	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT, path = GIT_STR_INIT;
 
-	cl_git_pass(git_buf_sets(&buf, "/path/to/nonexistent/commondir"));
-	cl_git_pass(git_buf_joinpath(&path,
+	cl_git_pass(git_str_sets(&buf, "/path/to/nonexistent/commondir"));
+	cl_git_pass(git_str_joinpath(&path,
 	            fixture.repo->commondir,
 	            "worktrees/testrepo-worktree/commondir"));
 	cl_git_pass(git_futils_writebuffer(&buf, path.ptr, O_RDWR, 0644));
@@ -154,8 +154,8 @@ void test_worktree_worktree__open_invalid_commondir(void)
 	cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree"));
 	cl_git_fail(git_repository_open_from_worktree(&repo, wt));
 
-	git_buf_dispose(&buf);
-	git_buf_dispose(&path);
+	git_str_dispose(&buf);
+	git_str_dispose(&path);
 	git_worktree_free(wt);
 }
 
@@ -163,10 +163,10 @@ void test_worktree_worktree__open_invalid_gitdir(void)
 {
 	git_worktree *wt;
 	git_repository *repo;
-	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT, path = GIT_STR_INIT;
 
-	cl_git_pass(git_buf_sets(&buf, "/path/to/nonexistent/gitdir"));
-	cl_git_pass(git_buf_joinpath(&path,
+	cl_git_pass(git_str_sets(&buf, "/path/to/nonexistent/gitdir"));
+	cl_git_pass(git_str_joinpath(&path,
 	            fixture.repo->commondir,
 	            "worktrees/testrepo-worktree/gitdir"));
 	cl_git_pass(git_futils_writebuffer(&buf, path.ptr, O_RDWR, 0644));
@@ -174,8 +174,8 @@ void test_worktree_worktree__open_invalid_gitdir(void)
 	cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree"));
 	cl_git_fail(git_repository_open_from_worktree(&repo, wt));
 
-	git_buf_dispose(&buf);
-	git_buf_dispose(&path);
+	git_str_dispose(&buf);
+	git_str_dispose(&path);
 	git_worktree_free(wt);
 }
 
@@ -183,16 +183,16 @@ void test_worktree_worktree__open_invalid_parent(void)
 {
 	git_worktree *wt;
 	git_repository *repo;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 
-	cl_git_pass(git_buf_sets(&buf, "/path/to/nonexistent/gitdir"));
+	cl_git_pass(git_str_sets(&buf, "/path/to/nonexistent/gitdir"));
 	cl_git_pass(git_futils_writebuffer(&buf,
 		    fixture.worktree->gitlink, O_RDWR, 0644));
 
 	cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree"));
 	cl_git_fail(git_repository_open_from_worktree(&repo, wt));
 
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 	git_worktree_free(wt);
 }
 
@@ -201,9 +201,9 @@ void test_worktree_worktree__init(void)
 	git_worktree *wt;
 	git_repository *repo;
 	git_reference *branch;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 
-	cl_git_pass(git_buf_joinpath(&path, fixture.repo->workdir, "../worktree-new"));
+	cl_git_pass(git_str_joinpath(&path, fixture.repo->workdir, "../worktree-new"));
 	cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-new", path.ptr, NULL));
 
 	/* Open and verify created repo */
@@ -211,7 +211,7 @@ void test_worktree_worktree__init(void)
 	cl_assert(git__suffixcmp(git_repository_workdir(repo), "worktree-new/") == 0);
 	cl_git_pass(git_branch_lookup(&branch, repo, "worktree-new", GIT_BRANCH_LOCAL));
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	git_worktree_free(wt);
 	git_reference_free(branch);
 	git_repository_free(repo);
@@ -222,12 +222,12 @@ void test_worktree_worktree__add_locked(void)
 	git_worktree *wt;
 	git_repository *repo;
 	git_reference *branch;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	git_worktree_add_options opts = GIT_WORKTREE_ADD_OPTIONS_INIT;
 
 	opts.lock = 1;
 
-	cl_git_pass(git_buf_joinpath(&path, fixture.repo->workdir, "../worktree-locked"));
+	cl_git_pass(git_str_joinpath(&path, fixture.repo->workdir, "../worktree-locked"));
 	cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-locked", path.ptr, &opts));
 
 	/* Open and verify created repo */
@@ -236,7 +236,7 @@ void test_worktree_worktree__add_locked(void)
 	cl_assert(git__suffixcmp(git_repository_workdir(repo), "worktree-locked/") == 0);
 	cl_git_pass(git_branch_lookup(&branch, repo, "worktree-locked", GIT_BRANCH_LOCAL));
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	git_worktree_free(wt);
 	git_reference_free(branch);
 	git_repository_free(repo);
@@ -247,16 +247,16 @@ void test_worktree_worktree__init_existing_branch(void)
 	git_reference *head, *branch;
 	git_commit *commit;
 	git_worktree *wt;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 
 	cl_git_pass(git_repository_head(&head, fixture.repo));
 	cl_git_pass(git_commit_lookup(&commit, fixture.repo, &head->target.oid));
 	cl_git_pass(git_branch_create(&branch, fixture.repo, "worktree-new", commit, false));
 
-	cl_git_pass(git_buf_joinpath(&path, fixture.repo->workdir, "../worktree-new"));
+	cl_git_pass(git_str_joinpath(&path, fixture.repo->workdir, "../worktree-new"));
 	cl_git_fail(git_worktree_add(&wt, fixture.repo, "worktree-new", path.ptr, NULL));
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	git_commit_free(commit);
 	git_reference_free(head);
 	git_reference_free(branch);
@@ -268,7 +268,7 @@ void test_worktree_worktree__add_with_explicit_branch(void)
 	git_commit *commit;
 	git_worktree *wt;
 	git_repository *wtrepo;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	git_worktree_add_options opts = GIT_WORKTREE_ADD_OPTIONS_INIT;
 
 	cl_git_pass(git_repository_head(&head, fixture.repo));
@@ -277,13 +277,13 @@ void test_worktree_worktree__add_with_explicit_branch(void)
 
 	opts.ref = branch;
 
-	cl_git_pass(git_buf_joinpath(&path, fixture.repo->workdir, "../worktree-with-different-name"));
+	cl_git_pass(git_str_joinpath(&path, fixture.repo->workdir, "../worktree-with-different-name"));
 	cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-with-different-name", path.ptr, &opts));
 	cl_git_pass(git_repository_open_from_worktree(&wtrepo, wt));
 	cl_git_pass(git_repository_head(&wthead, wtrepo));
 	cl_assert_equal_s(git_reference_name(wthead), "refs/heads/worktree-with-ref");
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	git_commit_free(commit);
 	git_reference_free(head);
 	git_reference_free(branch);
@@ -296,15 +296,15 @@ void test_worktree_worktree__add_with_explicit_branch(void)
 void test_worktree_worktree__init_existing_worktree(void)
 {
 	git_worktree *wt;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 
-	cl_git_pass(git_buf_joinpath(&path, fixture.repo->workdir, "../worktree-new"));
+	cl_git_pass(git_str_joinpath(&path, fixture.repo->workdir, "../worktree-new"));
 	cl_git_fail(git_worktree_add(&wt, fixture.repo, "testrepo-worktree", path.ptr, NULL));
 
 	cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree"));
 	cl_assert_equal_s(wt->gitlink_path, fixture.worktree->gitlink);
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	git_worktree_free(wt);
 }
 
@@ -312,42 +312,42 @@ void test_worktree_worktree__init_existing_path(void)
 {
 	const char *wtfiles[] = { "HEAD", "commondir", "gitdir", "index" };
 	git_worktree *wt;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	unsigned i;
 
 	/* Delete files to verify they have not been created by
 	 * the init call */
 	for (i = 0; i < ARRAY_SIZE(wtfiles); i++) {
-		cl_git_pass(git_buf_joinpath(&path,
+		cl_git_pass(git_str_joinpath(&path,
 			    fixture.worktree->gitdir, wtfiles[i]));
 		cl_git_pass(p_unlink(path.ptr));
 	}
 
-	cl_git_pass(git_buf_joinpath(&path, fixture.repo->workdir, "../testrepo-worktree"));
+	cl_git_pass(git_str_joinpath(&path, fixture.repo->workdir, "../testrepo-worktree"));
 	cl_git_fail(git_worktree_add(&wt, fixture.repo, "worktree-new", path.ptr, NULL));
 
 	/* Verify files have not been re-created */
 	for (i = 0; i < ARRAY_SIZE(wtfiles); i++) {
-		cl_git_pass(git_buf_joinpath(&path,
+		cl_git_pass(git_str_joinpath(&path,
 			    fixture.worktree->gitdir, wtfiles[i]));
 		cl_assert(!git_path_exists(path.ptr));
 	}
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 }
 
 void test_worktree_worktree__init_submodule(void)
 {
 	git_repository *repo, *sm, *wt;
 	git_worktree *worktree;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 
 	cleanup_fixture_worktree(&fixture);
 	repo = setup_fixture_submod2();
 
-	cl_git_pass(git_buf_joinpath(&path, repo->workdir, "sm_unchanged"));
+	cl_git_pass(git_str_joinpath(&path, repo->workdir, "sm_unchanged"));
 	cl_git_pass(git_repository_open(&sm, path.ptr));
-	cl_git_pass(git_buf_joinpath(&path, repo->workdir, "../worktree/"));
+	cl_git_pass(git_str_joinpath(&path, repo->workdir, "../worktree/"));
 	cl_git_pass(git_worktree_add(&worktree, sm, "repo-worktree", path.ptr, NULL));
 	cl_git_pass(git_repository_open_from_worktree(&wt, worktree));
 
@@ -356,10 +356,10 @@ void test_worktree_worktree__init_submodule(void)
 	cl_git_pass(git_path_prettify_dir(&path, sm->commondir, NULL));
 	cl_assert_equal_s(sm->commondir, wt->commondir);
 
-	cl_git_pass(git_buf_joinpath(&path, sm->gitdir, "worktrees/repo-worktree/"));
+	cl_git_pass(git_str_joinpath(&path, sm->gitdir, "worktrees/repo-worktree/"));
 	cl_assert_equal_s(path.ptr, wt->gitdir);
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	git_worktree_free(worktree);
 	git_repository_free(sm);
 	git_repository_free(wt);
@@ -388,13 +388,13 @@ void test_worktree_worktree__name(void)
 void test_worktree_worktree__path(void)
 {
 	git_worktree *wt;
-	git_buf expected_path = GIT_BUF_INIT;
+	git_str expected_path = GIT_STR_INIT;
 
-	cl_git_pass(git_buf_joinpath(&expected_path, clar_sandbox_path(), "testrepo-worktree"));
+	cl_git_pass(git_str_joinpath(&expected_path, clar_sandbox_path(), "testrepo-worktree"));
 	cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree"));
 	cl_assert_equal_s(git_worktree_path(wt), expected_path.ptr);
 
-	git_buf_dispose(&expected_path);
+	git_str_dispose(&expected_path);
 	git_worktree_free(wt);
 }