Merge pull request #448 from nulltoken/ntk/topic/treeentry-random-access

Add git_tree_frompath()

include/git2/oid.h

@@ -149,6 +149,16 @@ GIT_EXTERN(int) git_oid_cmp(const git_oid *a, const git_oid *b);
  */
 GIT_EXTERN(int) git_oid_ncmp(const git_oid *a, const git_oid *b, unsigned int len);
 
+/**
+ * Check if an oid equals an hex formatted object id.
+ *
+ * @param a oid structure.
+ * @param str input hex string of an object id.
+ * @return GIT_ENOTOID if str is not a valid hex string,
+ * GIT_SUCCESS in case of a match, GIT_ERROR otherwise.
+ */
+GIT_EXTERN(int) git_oid_streq(const git_oid *a, const char *str);
+
 /**
  * OID Shortener object
  */

include/git2/tree.h

@@ -268,6 +268,20 @@ GIT_EXTERN(void) git_treebuilder_filter(git_treebuilder *bld, int (*filter)(cons
  */
 GIT_EXTERN(int) git_treebuilder_write(git_oid *oid, git_repository *repo, git_treebuilder *bld);
 
+/**
+ * Retrieve the tree object containing a tree entry, given
+ * a relative path to this tree entry
+ *
+ * The returned tree is owned by the repository and
+ * should be closed with the `git_object_close` method.
+ *
+ * @param parent_out Pointer where to store the parent tree
+ * @param root A previously loaded tree which will be the root of the relative path
+ * @param treeentry_path Path to the tree entry from which to extract the last tree object
+ * @return GIT_SUCCESS on success; GIT_ENOTFOUND if the path does not lead to an
+ * entry, GIT_EINVALIDPATH or an error code
+ */
+GIT_EXTERN(int) git_tree_frompath(git_tree **parent_out, git_tree *root, const char *treeentry_path);
 /** @} */
 GIT_END_DECL
 #endif

src/oid.c

@@ -197,6 +197,17 @@ int git_oid_ncmp(const git_oid *oid_a, const git_oid *oid_b, unsigned int len)
 	return 0;
 }
 
+int git_oid_streq(const git_oid *a, const char *str)
+{
+	git_oid id;
+	int error;
+
+	if ((error = git_oid_fromstr(&id, str)) < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to convert '%s' to oid.", str);
+
+	return git_oid_cmp(a, &id) == 0 ? GIT_SUCCESS : GIT_ERROR;
+}
+
 typedef short node_index;
 
 typedef union {

src/transports/http.c

@@ -502,7 +502,6 @@ cleanup:
 static int http_negotiate_fetch(git_transport *transport, git_repository *repo, git_headarray *wants)
 {
 	transport_http *t = (transport_http *) transport;
-	GIT_UNUSED_ARG(list);
 	int error;
 	unsigned int i;
 	char buff[128];

src/tree.c

@@ -559,4 +559,49 @@ void git_treebuilder_free(git_treebuilder *bld)
 	free(bld);
 }
 
+static int tree_frompath(git_tree **parent_out, git_tree *root, const char *treeentry_path, int offset)
+{
+	char *slash_pos = NULL;
+	const git_tree_entry* entry;
+	int error = GIT_SUCCESS;
+	git_tree *subtree;
 
+	if (!*(treeentry_path + offset))
+		return git__rethrow(GIT_EINVALIDPATH, "Invalid relative path to a tree entry '%s'.", treeentry_path);
+
+	slash_pos = (char *)strchr(treeentry_path + offset, '/');
+
+	if (slash_pos == NULL)
+		return git_tree_lookup(parent_out, root->object.repo, git_object_id((const git_object *)root));
+
+	if (slash_pos == treeentry_path + offset)
+		return git__rethrow(GIT_EINVALIDPATH, "Invalid relative path to a tree entry '%s'.", treeentry_path);
+
+	*slash_pos = '\0';
+
+	entry = git_tree_entry_byname(root, treeentry_path + offset);
+
+	if (slash_pos != NULL)
+		*slash_pos = '/';
+
+	if (entry == NULL)
+		return git__rethrow(GIT_ENOTFOUND, "No tree entry can be found from the given tree and relative path '%s'.", treeentry_path);
+
+	if ((error = git_tree_lookup(&subtree, root->object.repo, &entry->oid)) < GIT_SUCCESS)
+		return error;
+
+	error = tree_frompath(parent_out, subtree, treeentry_path, slash_pos - treeentry_path + 1);
+
+	git_tree_close(subtree);
+	return error;
+}
+
+int git_tree_frompath(git_tree **parent_out, git_tree *root, const char *treeentry_path)
+{
+	char buffer[GIT_PATH_MAX];
+
+	assert(root && treeentry_path);
+
+	strcpy(buffer, treeentry_path);
+	return tree_frompath(parent_out, root, buffer, 0);
+}

tests-clay/clay.h

@@ -57,17 +57,6 @@ void cl_fixture_cleanup(const char *fixture_name);
 /**
  * Test method declarations
  */
-extern void test_status_single__hash_single_file(void);
-extern void test_status_worktree__initialize(void);
-extern void test_status_worktree__cleanup(void);
-extern void test_status_worktree__whole_repository(void);
-extern void test_status_worktree__empty_repository(void);
-extern void test_network_remotes__initialize(void);
-extern void test_network_remotes__cleanup(void);
-extern void test_network_remotes__parsing(void);
-extern void test_network_remotes__refspec_parsing(void);
-extern void test_network_remotes__fnmatch(void);
-extern void test_network_remotes__transform(void);
 extern void test_core_dirent__dont_traverse_dot(void);
 extern void test_core_dirent__traverse_subfolder(void);
 extern void test_core_dirent__traverse_slash_terminated_folder(void);
@@ -76,6 +65,8 @@ extern void test_core_dirent__traverse_weird_filenames(void);
 extern void test_core_filebuf__0(void);
 extern void test_core_filebuf__1(void);
 extern void test_core_filebuf__2(void);
+extern void test_core_oid__initialize(void);
+extern void test_core_oid__streq(void);
 extern void test_core_path__0(void);
 extern void test_core_path__1(void);
 extern void test_core_path__2(void);
@@ -91,5 +82,21 @@ extern void test_core_strtol__int64(void);
 extern void test_core_vector__0(void);
 extern void test_core_vector__1(void);
 extern void test_core_vector__2(void);
+extern void test_network_remotes__initialize(void);
+extern void test_network_remotes__cleanup(void);
+extern void test_network_remotes__parsing(void);
+extern void test_network_remotes__refspec_parsing(void);
+extern void test_network_remotes__fnmatch(void);
+extern void test_network_remotes__transform(void);
+extern void test_object_tree_frompath__initialize(void);
+extern void test_object_tree_frompath__cleanup(void);
+extern void test_object_tree_frompath__retrieve_tree_from_path_to_treeentry(void);
+extern void test_object_tree_frompath__fail_when_processing_an_unknown_tree_segment(void);
+extern void test_object_tree_frompath__fail_when_processing_an_invalid_path(void);
+extern void test_status_single__hash_single_file(void);
+extern void test_status_worktree__initialize(void);
+extern void test_status_worktree__cleanup(void);
+extern void test_status_worktree__whole_repository(void);
+extern void test_status_worktree__empty_repository(void);
 
 #endif

tests-clay/clay_main.c

@@ -660,107 +660,123 @@ cl_fs_cleanup(void)
 
 
 static const struct clay_func _all_callbacks[] = {
-    {"hash_single_file", &test_status_single__hash_single_file, 0},
+    {"dont_traverse_dot", &test_core_dirent__dont_traverse_dot, 0},
-	{"whole_repository", &test_status_worktree__whole_repository, 1},
+	{"traverse_subfolder", &test_core_dirent__traverse_subfolder, 0},
-	{"empty_repository", &test_status_worktree__empty_repository, 1},
+	{"traverse_slash_terminated_folder", &test_core_dirent__traverse_slash_terminated_folder, 0},
-	{"parsing", &test_network_remotes__parsing, 2},
+	{"dont_traverse_empty_folders", &test_core_dirent__dont_traverse_empty_folders, 0},
-	{"refspec_parsing", &test_network_remotes__refspec_parsing, 2},
+	{"traverse_weird_filenames", &test_core_dirent__traverse_weird_filenames, 0},
-	{"fnmatch", &test_network_remotes__fnmatch, 2},
+	{"0", &test_core_filebuf__0, 1},
-	{"transform", &test_network_remotes__transform, 2},
+	{"1", &test_core_filebuf__1, 1},
-	{"dont_traverse_dot", &test_core_dirent__dont_traverse_dot, 3},
+	{"2", &test_core_filebuf__2, 1},
-	{"traverse_subfolder", &test_core_dirent__traverse_subfolder, 3},
+	{"streq", &test_core_oid__streq, 2},
-	{"traverse_slash_terminated_folder", &test_core_dirent__traverse_slash_terminated_folder, 3},
+	{"0", &test_core_path__0, 3},
-	{"dont_traverse_empty_folders", &test_core_dirent__dont_traverse_empty_folders, 3},
+	{"1", &test_core_path__1, 3},
-	{"traverse_weird_filenames", &test_core_dirent__traverse_weird_filenames, 3},
+	{"2", &test_core_path__2, 3},
-	{"0", &test_core_filebuf__0, 4},
+	{"5", &test_core_path__5, 3},
-	{"1", &test_core_filebuf__1, 4},
+	{"6", &test_core_path__6, 3},
-	{"2", &test_core_filebuf__2, 4},
+	{"delete_recursive", &test_core_rmdir__delete_recursive, 4},
-	{"0", &test_core_path__0, 5},
+	{"fail_to_delete_non_empty_dir", &test_core_rmdir__fail_to_delete_non_empty_dir, 4},
-	{"1", &test_core_path__1, 5},
+	{"0", &test_core_string__0, 5},
-	{"2", &test_core_path__2, 5},
+	{"1", &test_core_string__1, 5},
-	{"5", &test_core_path__5, 5},
+	{"int32", &test_core_strtol__int32, 6},
-	{"6", &test_core_path__6, 5},
+	{"int64", &test_core_strtol__int64, 6},
-	{"delete_recursive", &test_core_rmdir__delete_recursive, 6},
+	{"0", &test_core_vector__0, 7},
-	{"fail_to_delete_non_empty_dir", &test_core_rmdir__fail_to_delete_non_empty_dir, 6},
+	{"1", &test_core_vector__1, 7},
-	{"0", &test_core_string__0, 7},
+	{"2", &test_core_vector__2, 7},
-	{"1", &test_core_string__1, 7},
+	{"parsing", &test_network_remotes__parsing, 8},
-	{"int32", &test_core_strtol__int32, 8},
+	{"refspec_parsing", &test_network_remotes__refspec_parsing, 8},
-	{"int64", &test_core_strtol__int64, 8},
+	{"fnmatch", &test_network_remotes__fnmatch, 8},
-	{"0", &test_core_vector__0, 9},
+	{"transform", &test_network_remotes__transform, 8},
-	{"1", &test_core_vector__1, 9},
+	{"retrieve_tree_from_path_to_treeentry", &test_object_tree_frompath__retrieve_tree_from_path_to_treeentry, 9},
-	{"2", &test_core_vector__2, 9}
+	{"fail_when_processing_an_unknown_tree_segment", &test_object_tree_frompath__fail_when_processing_an_unknown_tree_segment, 9},
+	{"fail_when_processing_an_invalid_path", &test_object_tree_frompath__fail_when_processing_an_invalid_path, 9},
+	{"hash_single_file", &test_status_single__hash_single_file, 10},
+	{"whole_repository", &test_status_worktree__whole_repository, 11},
+	{"empty_repository", &test_status_worktree__empty_repository, 11}
 };
 
 static const struct clay_suite _all_suites[] = {
     {
-        "status::single",
-        {NULL, NULL, 0},
-        {NULL, NULL, 0},
-        &_all_callbacks[0], 1
-    },
-	{
-        "status::worktree",
-        {"initialize", &test_status_worktree__initialize, 1},
-        {"cleanup", &test_status_worktree__cleanup, 1},
-        &_all_callbacks[1], 2
-    },
-	{
-        "network::remotes",
-        {"initialize", &test_network_remotes__initialize, 2},
-        {"cleanup", &test_network_remotes__cleanup, 2},
-        &_all_callbacks[3], 4
-    },
-	{
         "core::dirent",
         {NULL, NULL, 0},
         {NULL, NULL, 0},
-        &_all_callbacks[7], 5
+        &_all_callbacks[0], 5
     },
 	{
         "core::filebuf",
         {NULL, NULL, 0},
         {NULL, NULL, 0},
-        &_all_callbacks[12], 3
+        &_all_callbacks[5], 3
+    },
+	{
+        "core::oid",
+        {"initialize", &test_core_oid__initialize, 2},
+        {NULL, NULL, 0},
+        &_all_callbacks[8], 1
     },
 	{
         "core::path",
         {NULL, NULL, 0},
         {NULL, NULL, 0},
-        &_all_callbacks[15], 5
+        &_all_callbacks[9], 5
     },
 	{
         "core::rmdir",
-        {"initialize", &test_core_rmdir__initialize, 6},
+        {"initialize", &test_core_rmdir__initialize, 4},
         {NULL, NULL, 0},
-        &_all_callbacks[20], 2
+        &_all_callbacks[14], 2
     },
 	{
         "core::string",
         {NULL, NULL, 0},
         {NULL, NULL, 0},
-        &_all_callbacks[22], 2
+        &_all_callbacks[16], 2
     },
 	{
         "core::strtol",
         {NULL, NULL, 0},
         {NULL, NULL, 0},
-        &_all_callbacks[24], 2
+        &_all_callbacks[18], 2
     },
 	{
         "core::vector",
         {NULL, NULL, 0},
         {NULL, NULL, 0},
-        &_all_callbacks[26], 3
+        &_all_callbacks[20], 3
+    },
+	{
+        "network::remotes",
+        {"initialize", &test_network_remotes__initialize, 8},
+        {"cleanup", &test_network_remotes__cleanup, 8},
+        &_all_callbacks[23], 4
+    },
+	{
+        "object::tree::frompath",
+        {"initialize", &test_object_tree_frompath__initialize, 9},
+        {"cleanup", &test_object_tree_frompath__cleanup, 9},
+        &_all_callbacks[27], 3
+    },
+	{
+        "status::single",
+        {NULL, NULL, 0},
+        {NULL, NULL, 0},
+        &_all_callbacks[30], 1
+    },
+	{
+        "status::worktree",
+        {"initialize", &test_status_worktree__initialize, 11},
+        {"cleanup", &test_status_worktree__cleanup, 11},
+        &_all_callbacks[31], 2
     }
 };
 
-static const char _suites_str[] = "status::single, status::worktree, network::remotes, core::dirent, core::filebuf, core::path, core::rmdir, core::string, core::strtol, core::vector";
+static const char _suites_str[] = "core::dirent, core::filebuf, core::oid, core::path, core::rmdir, core::string, core::strtol, core::vector, network::remotes, object::tree::frompath, status::single, status::worktree";
 
 int _MAIN_CC main(int argc, char *argv[])
 {
     return clay_test(
         argc, argv, _suites_str,
-        _all_callbacks, 29,
+        _all_callbacks, 33,
-        _all_suites, 10
+        _all_suites, 12
     );
 }

tests-clay/core/oid.c

@@ -0,0 +1,18 @@
+#include "clay_libgit2.h"
+
+static git_oid id;
+const char *str_oid = "ae90f12eea699729ed24555e40b9fd669da12a12";
+
+void test_core_oid__initialize(void)
+{
+	cl_git_pass(git_oid_fromstr(&id, str_oid));
+}
+
+void test_core_oid__streq(void)
+{
+	cl_assert(git_oid_streq(&id, str_oid) == GIT_SUCCESS);
+	cl_assert(git_oid_streq(&id, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef") == GIT_ERROR);
+
+	cl_assert(git_oid_streq(&id, "deadbeef") == GIT_ENOTOID);
+	cl_assert(git_oid_streq(&id, "I'm not an oid.... :)") == GIT_ENOTOID);
+}

tests-clay/object/tree/frompath.c

@@ -0,0 +1,76 @@
+#include "clay_libgit2.h"
+
+#define REPOSITORY_FOLDER "testrepo.git"
+
+static git_repository *repo;
+const char *tree_with_subtrees_oid = "ae90f12eea699729ed24555e40b9fd669da12a12";
+static	git_tree *tree;
+
+void test_object_tree_frompath__initialize(void)
+{
+	git_oid id;
+
+	cl_fixture_sandbox(REPOSITORY_FOLDER);
+	cl_git_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
+	cl_assert(repo != NULL);
+
+	cl_git_pass(git_oid_fromstr(&id, tree_with_subtrees_oid));
+	cl_git_pass(git_tree_lookup(&tree, repo, &id));
+	cl_assert(tree != NULL);
+}
+
+void test_object_tree_frompath__cleanup(void)
+{
+	git_tree_close(tree);
+	git_repository_free(repo);
+}
+
+static void assert_tree_from_path(git_tree *root, const char *path, git_error expected_result, const char *expected_raw_oid)
+{
+	git_tree *containing_tree = NULL;
+
+	cl_assert(git_tree_frompath(&containing_tree, root, path) == expected_result);
+	
+	if (containing_tree == NULL && expected_result != GIT_SUCCESS)
+		return;
+	
+	cl_assert(containing_tree != NULL && expected_result == GIT_SUCCESS);
+
+	cl_assert(git_oid_streq(git_object_id((const git_object *)containing_tree), expected_raw_oid) == GIT_SUCCESS);
+
+	git_tree_close(containing_tree);
+}
+
+void test_object_tree_frompath__retrieve_tree_from_path_to_treeentry(void)
+{
+	/* Will return self if given a one path segment... */
+	assert_tree_from_path(tree, "README", GIT_SUCCESS, tree_with_subtrees_oid);
+	
+	/* ...even one that lead to a non existent tree entry. */
+	assert_tree_from_path(tree, "i-do-not-exist.txt", GIT_SUCCESS, tree_with_subtrees_oid);
+	
+	/* Will return fgh tree oid given this following path... */
+	assert_tree_from_path(tree, "ab/de/fgh/1.txt", GIT_SUCCESS, "3259a6bd5b57fb9c1281bb7ed3167b50f224cb54");
+	
+	/* ... and ab tree oid given this one. */
+	assert_tree_from_path(tree, "ab/de", GIT_SUCCESS, "f1425cef211cc08caa31e7b545ffb232acb098c3");
+
+	/* Will succeed if given a valid path which leads to a tree entry which doesn't exist */
+	assert_tree_from_path(tree, "ab/de/fgh/i-do-not-exist.txt", GIT_SUCCESS, "3259a6bd5b57fb9c1281bb7ed3167b50f224cb54");
+}
+
+void test_object_tree_frompath__fail_when_processing_an_unknown_tree_segment(void)
+{
+	assert_tree_from_path(tree, "nope/de/fgh/1.txt", GIT_ENOTFOUND, NULL);
+	assert_tree_from_path(tree, "ab/me-neither/fgh/2.txt", GIT_ENOTFOUND, NULL);
+}
+
+void test_object_tree_frompath__fail_when_processing_an_invalid_path(void)
+{
+	assert_tree_from_path(tree, "/", GIT_EINVALIDPATH, NULL);
+	assert_tree_from_path(tree, "/ab", GIT_EINVALIDPATH, NULL);
+	assert_tree_from_path(tree, "/ab/de", GIT_EINVALIDPATH, NULL);
+	assert_tree_from_path(tree, "ab/", GIT_EINVALIDPATH, NULL);
+	assert_tree_from_path(tree, "ab//de", GIT_EINVALIDPATH, NULL);
+	assert_tree_from_path(tree, "ab/de/", GIT_EINVALIDPATH, NULL);
+}

tests/t09-tree.c

@@ -187,22 +187,22 @@ BEGIN_TEST(write3, "write a hierarchical tree from a memory")
 	must_pass(git_treebuilder_write(&subtree_id,repo,builder));
 	git_treebuilder_free(builder);
 
-        // create parent tree
+	// create parent tree
-        must_pass(git_tree_lookup(&tree, repo, &id));
+	must_pass(git_tree_lookup(&tree, repo, &id));
 	must_pass(git_treebuilder_create(&builder, tree));
 	must_pass(git_treebuilder_insert(NULL,builder,"new",&subtree_id,040000));
 	must_pass(git_treebuilder_write(&id_hiearar,repo,builder));
 	git_treebuilder_free(builder);
 	git_tree_close(tree);
 
-        must_be_true(git_oid_cmp(&id_hiearar, &id3) == 0);
+	must_be_true(git_oid_cmp(&id_hiearar, &id3) == 0);
 
-        // check data is correct
+	// check data is correct
-        must_pass(git_tree_lookup(&tree, repo, &id_hiearar));
+	must_pass(git_tree_lookup(&tree, repo, &id_hiearar));
-        must_be_true(2 == git_tree_entrycount(tree));
+	must_be_true(2 == git_tree_entrycount(tree));
 	git_tree_close(tree);
 
-        close_temp_repo(repo);
+	close_temp_repo(repo);
 
 END_TEST
 
@@ -215,4 +215,3 @@ BEGIN_SUITE(tree)
 	ADD_TEST(write2);
 	ADD_TEST(write3);
 END_SUITE
-

tests/t10-refs.c

@@ -1004,10 +1004,10 @@ BEGIN_TEST(list0, "try to list all the references in our test repo")
 			printf("# %s\n", ref_list.strings[i]);
 	}*/
 
-	/* We have exactly 8 refs in total if we include the packed ones:
+	/* We have exactly 9 refs in total if we include the packed ones:
 	 * there is a reference that exists both in the packfile and as
 	 * loose, but we only list it once */
-	must_be_true(ref_list.count == 8);
+	must_be_true(ref_list.count == 9);
 
 	git_strarray_free(&ref_list);
 	git_repository_free(repo);