Major submodule rewrite

This replaces the old submodule API with a new extended API that
supports most of the things that can be done with `git submodule`.

include/git2/errors.h

@@ -54,6 +54,7 @@ typedef enum {
 	GITERR_TREE,
 	GITERR_INDEXER,
 	GITERR_SSL,
+	GITERR_SUBMODULE,
 } git_error_t;
 
 /**

src/config_file.c

@@ -253,11 +253,17 @@ static int config_set(git_config_file *cfg, const char *name, const char *value)
 		char *tmp = NULL;
 
 		git__free(key);
+
 		if (existing->next != NULL) {
 			giterr_set(GITERR_CONFIG, "Multivar incompatible with simple set");
 			return -1;
 		}
 
+		/* don't update if old and new values already match */
+		if ((!existing->value && !value) ||
+			(existing->value && value && !strcmp(existing->value, value)))
+			return 0;
+
 		if (value) {
 			tmp = git__strdup(value);
 			GITERR_CHECK_ALLOC(tmp);

src/config_file.h

@@ -19,12 +19,24 @@ GIT_INLINE(void) git_config_file_free(git_config_file *cfg)
 	cfg->free(cfg);
 }
 
+GIT_INLINE(int) git_config_file_get_string(
+	const char **out, git_config_file *cfg, const char *name)
+{
+	return cfg->get(cfg, name, out);
+}
+
 GIT_INLINE(int) git_config_file_set_string(
 	git_config_file *cfg, const char *name, const char *value)
 {
 	return cfg->set(cfg, name, value);
 }
 
+GIT_INLINE(int) git_config_file_delete(
+	git_config_file *cfg, const char *name)
+{
+	return cfg->del(cfg, name);
+}
+
 GIT_INLINE(int) git_config_file_foreach(
 	git_config_file *cfg,
 	int (*fn)(const char *key, const char *value, void *data),

src/diff.c

@@ -530,7 +530,7 @@ static int maybe_modified(
 				status = GIT_DELTA_UNMODIFIED;
 			else if (git_submodule_lookup(&sub, diff->repo, nitem->path) < 0)
 				return -1;
-			else if (sub->ignore == GIT_SUBMODULE_IGNORE_ALL)
+			else if (git_submodule_ignore(sub) == GIT_SUBMODULE_IGNORE_ALL)
 				status = GIT_DELTA_UNMODIFIED;
 			else {
 				/* TODO: support other GIT_SUBMODULE_IGNORE values */

src/submodule.h

+/*
+ * Copyright (C) 2012 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_submodule_h__
+#define INCLUDE_submodule_h__
+
+/* Notes:
+ *
+ * Submodule information can be in four places: the index, the config files
+ * (both .git/config and .gitmodules), the HEAD tree, and the working
+ * directory.
+ *
+ * In the index:
+ * - submodule is found by path
+ * - may be missing, present, or of the wrong type
+ * - will have an oid if present
+ *
+ * In the HEAD tree:
+ * - submodule is found by path
+ * - may be missing, present, or of the wrong type
+ * - will have an oid if present
+ *
+ * In the config files:
+ * - submodule is found by submodule "name" which is usually the path
+ * - may be missing or present
+ * - will have a name, path, url, and other properties
+ *
+ * In the working directory:
+ * - submodule is found by path
+ * - may be missing, an empty directory, a checked out directory,
+ *   or of the wrong type
+ * - if checked out, will have a HEAD oid
+ * - if checked out, will have git history that can be used to compare oids
+ * - if checked out, may have modified files and/or untracked files
+ */
+
+/**
+ * Description of submodule
+ *
+ * This record describes a submodule found in a repository.  There should be
+ * an entry for every submodule found in the HEAD and index, and for every
+ * submodule described in .gitmodules.  The fields are as follows:
+ *
+ * - `owner` is the git_repository containing this submodule
+ * - `name` is the name of the submodule from .gitmodules.
+ * - `path` is the path to the submodule from the repo root.  It is almost
+ *    always the same as `name`.
+ * - `url` is the url for the submodule.
+ * - `tree_oid` is the SHA1 for the submodule path in the repo HEAD.
+ * - `index_oid` is the SHA1 for the submodule recorded in the index.
+ * - `workdir_oid` is the SHA1 for the HEAD of the checked out submodule.
+ * - `update` is a git_submodule_update_t value - see gitmodules(5) update.
+ * - `ignore` is a git_submodule_ignore_t value - see gitmodules(5) ignore.
+ * - `fetch_recurse` is 0 or 1 - see gitmodules(5) fetchRecurseSubmodules.
+ * - `refcount` tracks how many hashmap entries there are for this submodule.
+ *   It only comes into play if the name and path of the submodule differ.
+ * - `flags` is for internal use, tracking where this submodule has been
+ *   found (head, index, config, workdir) and other misc info about it.
+ *
+ * If the submodule has been added to .gitmodules but not yet git added,
+ * then the `index_oid` will be valid and zero.  If the submodule has been
+ * deleted, but the delete has not been committed yet, then the `index_oid`
+ * will be set, but the `url` will be NULL.
+ */
+struct git_submodule {
+	git_repository *owner;
+	char *name;
+	char *path; /* important: may point to same string data as "name" */
+	char *url;
+	uint32_t flags;
+	git_oid head_oid;
+	git_oid index_oid;
+	git_oid wd_oid;
+	/* information from config */
+	git_submodule_update_t update;
+	git_submodule_update_t update_default;
+	git_submodule_ignore_t ignore;
+	git_submodule_ignore_t ignore_default;
+	int fetch_recurse;
+	/* internal information */
+	int refcount;
+};
+
+/* Additional flags on top of public GIT_SUBMODULE_STATUS values */
+#define GIT_SUBMODULE_STATUS__WD_SCANNED      (1u << 15)
+#define GIT_SUBMODULE_STATUS__HEAD_OID_VALID  (1u << 16)
+#define GIT_SUBMODULE_STATUS__INDEX_OID_VALID (1u << 17)
+#define GIT_SUBMODULE_STATUS__WD_OID_VALID    (1u << 18)
+#define GIT_SUBMODULE_STATUS__INDEX_MULTIPLE_ENTRIES (1u << 19)
+
+#endif

tests-clar/status/submodules.c

@@ -3,24 +3,17 @@
 #include "path.h"
 #include "posix.h"
 #include "status_helpers.h"
+#include "../submodule/submodule_helpers.h"
 
 static git_repository *g_repo = NULL;
 
 void test_status_submodules__initialize(void)
 {
-	git_buf modpath = GIT_BUF_INIT;
-
 	g_repo = cl_git_sandbox_init("submodules");
 
 	cl_fixture_sandbox("testrepo.git");
 
-	cl_git_pass(git_buf_sets(&modpath, git_repository_workdir(g_repo)));
-	cl_assert(git_path_dirname_r(&modpath, modpath.ptr) >= 0);
-	cl_git_pass(git_buf_joinpath(&modpath, modpath.ptr, "testrepo.git\n"));
-
-	p_rename("submodules/gitmodules", "submodules/.gitmodules");
-	cl_git_append2file("submodules/.gitmodules", modpath.ptr);
-	git_buf_free(&modpath);
+	rewrite_gitmodules(git_repository_workdir(g_repo));
 
 	p_rename("submodules/testrepo/.gitted", "submodules/testrepo/.git");
 }
@@ -28,6 +21,7 @@ void test_status_submodules__initialize(void)
 void test_status_submodules__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
+	cl_fixture_cleanup("testrepo.git");
 }
 
 void test_status_submodules__api(void)
@@ -40,8 +34,8 @@ void test_status_submodules__api(void)
 
 	cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo"));
 	cl_assert(sm != NULL);
-	cl_assert_equal_s("testrepo", sm->name);
-	cl_assert_equal_s("testrepo", sm->path);
+	cl_assert_equal_s("testrepo", git_submodule_name(sm));
+	cl_assert_equal_s("testrepo", git_submodule_path(sm));
 }
 
 void test_status_submodules__0(void)

tests-clar/submodule/lookup.c

+#include "clar_libgit2.h"
+#include "submodule_helpers.h"
+#include "posix.h"
+
+static git_repository *g_repo = NULL;
+
+void test_submodule_lookup__initialize(void)
+{
+	g_repo = cl_git_sandbox_init("submod2");
+
+	cl_fixture_sandbox("submod2_target");
+	p_rename("submod2_target/.gitted", "submod2_target/.git");
+
+	/* must create submod2_target before rewrite so prettify will work */
+	rewrite_gitmodules(git_repository_workdir(g_repo));
+	p_rename("submod2/not_submodule/.gitted", "submod2/not_submodule/.git");
+}
+
+void test_submodule_lookup__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+	cl_fixture_cleanup("submod2_target");
+}
+
+void test_submodule_lookup__simple_lookup(void)
+{
+	git_submodule *sm;
+
+	/* lookup existing */
+	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
+	cl_assert(sm);
+
+	/* lookup pending change in .gitmodules that is not in HEAD */
+	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_added_and_uncommited"));
+	cl_assert(sm);
+
+	/* lookup git repo subdir that is not added as submodule */
+	cl_assert(git_submodule_lookup(&sm, g_repo, "not_submodule") == GIT_EEXISTS);
+
+	/* lookup existing directory that is not a submodule */
+	cl_assert(git_submodule_lookup(&sm, g_repo, "just_a_dir") == GIT_ENOTFOUND);
+
+	/* lookup existing file that is not a submodule */
+	cl_assert(git_submodule_lookup(&sm, g_repo, "just_a_file") == GIT_ENOTFOUND);
+
+	/* lookup non-existent item */
+	cl_assert(git_submodule_lookup(&sm, g_repo, "no_such_file") == GIT_ENOTFOUND);
+}
+
+void test_submodule_lookup__accessors(void)
+{
+	git_submodule *sm;
+	const char *oid = "480095882d281ed676fe5b863569520e54a7d5c0";
+
+	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
+	cl_assert(git_submodule_owner(sm) == g_repo);
+	cl_assert_equal_s("sm_unchanged", git_submodule_name(sm));
+	cl_assert(git__suffixcmp(git_submodule_path(sm), "sm_unchanged") == 0);
+	cl_assert(git__suffixcmp(git_submodule_url(sm), "/submod2_target") == 0);
+
+	cl_assert(git_oid_streq(git_submodule_index_oid(sm), oid) == 0);
+	cl_assert(git_oid_streq(git_submodule_head_oid(sm), oid) == 0);
+	cl_assert(git_oid_streq(git_submodule_wd_oid(sm), oid) == 0);
+
+	cl_assert(git_submodule_ignore(sm) == GIT_SUBMODULE_IGNORE_NONE);
+	cl_assert(git_submodule_update(sm) == GIT_SUBMODULE_UPDATE_CHECKOUT);
+
+	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
+	cl_assert_equal_s("sm_changed_head", git_submodule_name(sm));
+
+	cl_assert(git_oid_streq(git_submodule_index_oid(sm), oid) == 0);
+	cl_assert(git_oid_streq(git_submodule_head_oid(sm), oid) == 0);
+	cl_assert(git_oid_streq(git_submodule_wd_oid(sm),
+		"3d9386c507f6b093471a3e324085657a3c2b4247") == 0);
+
+	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_added_and_uncommited"));
+	cl_assert_equal_s("sm_added_and_uncommited", git_submodule_name(sm));
+
+	cl_assert(git_oid_streq(git_submodule_index_oid(sm), oid) == 0);
+	cl_assert(git_submodule_head_oid(sm) == NULL);
+	cl_assert(git_oid_streq(git_submodule_wd_oid(sm), oid) == 0);
+
+	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_missing_commits"));
+	cl_assert_equal_s("sm_missing_commits", git_submodule_name(sm));
+
+	cl_assert(git_oid_streq(git_submodule_index_oid(sm), oid) == 0);
+	cl_assert(git_oid_streq(git_submodule_head_oid(sm), oid) == 0);
+	cl_assert(git_oid_streq(git_submodule_wd_oid(sm),
+		"5e4963595a9774b90524d35a807169049de8ccad") == 0);
+}
+
+typedef struct {
+	int count;
+} sm_lookup_data;
+
+static int sm_lookup_cb(git_submodule *sm, const char *name, void *payload)
+{
+	sm_lookup_data *data = payload;
+	data->count += 1;
+	cl_assert_equal_s(git_submodule_name(sm), name);
+	return 0;
+}
+
+void test_submodule_lookup__foreach(void)
+{
+	sm_lookup_data data;
+	memset(&data, 0, sizeof(data));
+	cl_git_pass(git_submodule_foreach(g_repo, sm_lookup_cb, &data));
+	cl_assert_equal_i(7, data.count);
+}

tests-clar/submodule/modify.c

+#include "clar_libgit2.h"
+#include "posix.h"
+#include "path.h"
+#include "submodule_helpers.h"
+
+static git_repository *g_repo = NULL;
+
+#define SM_LIBGIT2_URL "https://github.com/libgit2/libgit2.git"
+#define SM_LIBGIT2     "sm_libgit2"
+#define SM_LIBGIT2B    "sm_libgit2b"
+
+void test_submodule_modify__initialize(void)
+{
+	g_repo = cl_git_sandbox_init("submod2");
+
+	cl_fixture_sandbox("submod2_target");
+	p_rename("submod2_target/.gitted", "submod2_target/.git");
+
+	/* must create submod2_target before rewrite so prettify will work */
+	rewrite_gitmodules(git_repository_workdir(g_repo));
+	p_rename("submod2/not_submodule/.gitted", "submod2/not_submodule/.git");
+}
+
+void test_submodule_modify__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+	cl_fixture_cleanup("submod2_target");
+}
+
+void test_submodule_modify__add(void)
+{
+	git_submodule *sm;
+	git_config *cfg;
+	const char *s;
+
+	/* re-add existing submodule */
+	cl_assert(
+		git_submodule_add_setup(NULL, g_repo, "whatever", "sm_unchanged", 1) ==
+		GIT_EEXISTS );
+
+	/* add a submodule using a gitlink */
+
+	cl_git_pass(
+		git_submodule_add_setup(&sm, g_repo, SM_LIBGIT2_URL, SM_LIBGIT2, 1)
+		);
+
+	cl_assert(git_path_isfile("submod2/" SM_LIBGIT2 "/.git"));
+
+	cl_assert(git_path_isdir("submod2/.git/modules"));
+	cl_assert(git_path_isdir("submod2/.git/modules/" SM_LIBGIT2));
+	cl_assert(git_path_isfile("submod2/.git/modules/" SM_LIBGIT2 "/HEAD"));
+
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+	cl_git_pass(
+		git_config_get_string(&s, cfg, "submodule." SM_LIBGIT2 ".url"));
+	cl_assert_equal_s(s, SM_LIBGIT2_URL);
+	git_config_free(cfg);
+
+	/* add a submodule not using a gitlink */
+
+	cl_git_pass(
+		git_submodule_add_setup(&sm, g_repo, SM_LIBGIT2_URL, SM_LIBGIT2B, 0)
+		);
+
+	cl_assert(git_path_isdir("submod2/" SM_LIBGIT2B "/.git"));
+	cl_assert(git_path_isfile("submod2/" SM_LIBGIT2B "/.git/HEAD"));
+	cl_assert(!git_path_exists("submod2/.git/modules/" SM_LIBGIT2B));
+
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+	cl_git_pass(
+		git_config_get_string(&s, cfg, "submodule." SM_LIBGIT2B ".url"));
+	cl_assert_equal_s(s, SM_LIBGIT2_URL);
+	git_config_free(cfg);
+}
+
+static int delete_one_config(
+	const char *var_name, const char *value, void *payload)
+{
+	git_config *cfg = payload;
+	GIT_UNUSED(value);
+	return git_config_delete(cfg, var_name);
+}
+
+static int init_one_submodule(
+	git_submodule *sm, const char *name, void *payload)
+{
+	GIT_UNUSED(name);
+	GIT_UNUSED(payload);
+	return git_submodule_init(sm, false);
+}
+
+void test_submodule_modify__init(void)
+{
+	git_config *cfg;
+	const char *str;
+
+	/* erase submodule data from .git/config */
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+	cl_git_pass(
+		git_config_foreach_match(cfg, "submodule\\..*", delete_one_config, cfg));
+	git_config_free(cfg);
+
+	/* confirm no submodule data in config */
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+	cl_git_fail(git_config_get_string(&str, cfg, "submodule.sm_unchanged.url"));
+	cl_git_fail(git_config_get_string(&str, cfg, "submodule.sm_changed_head.url"));
+	cl_git_fail(git_config_get_string(&str, cfg, "submodule.sm_added_and_uncommited.url"));
+	git_config_free(cfg);
+
+	/* call init and see that settings are copied */
+	cl_git_pass(git_submodule_foreach(g_repo, init_one_submodule, NULL));
+
+	git_submodule_reload_all(g_repo);
+
+	/* confirm submodule data in config */
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+	cl_git_pass(git_config_get_string(&str, cfg, "submodule.sm_unchanged.url"));
+	cl_assert(git__suffixcmp(str, "/submod2_target") == 0);
+	cl_git_pass(git_config_get_string(&str, cfg, "submodule.sm_changed_head.url"));
+	cl_assert(git__suffixcmp(str, "/submod2_target") == 0);
+	cl_git_pass(git_config_get_string(&str, cfg, "submodule.sm_added_and_uncommited.url"));
+	cl_assert(git__suffixcmp(str, "/submod2_target") == 0);
+	git_config_free(cfg);
+}
+
+static int sync_one_submodule(
+	git_submodule *sm, const char *name, void *payload)
+{
+	GIT_UNUSED(name);
+	GIT_UNUSED(payload);
+	return git_submodule_sync(sm);
+}
+
+void test_submodule_modify__sync(void)
+{
+	git_submodule *sm1, *sm2, *sm3;
+	git_config *cfg;
+	const char *str;
+
+#define SM1 "sm_unchanged"
+#define SM2 "sm_changed_head"
+#define SM3 "sm_added_and_uncommited"
+
+	/* look up some submodules */
+	cl_git_pass(git_submodule_lookup(&sm1, g_repo, SM1));
+	cl_git_pass(git_submodule_lookup(&sm2, g_repo, SM2));
+	cl_git_pass(git_submodule_lookup(&sm3, g_repo, SM3));
+
+	/* At this point, the .git/config URLs for the submodules have
+	 * not be rewritten with the absolute paths (although the
+	 * .gitmodules have.  Let's confirm that they DO NOT match
+	 * yet, then we can do a sync to make them match...
+	 */
+
+	/* check submodule info does not match before sync */
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+	cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM1".url"));
+	cl_assert(strcmp(git_submodule_url(sm1), str) != 0);
+	cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM2".url"));
+	cl_assert(strcmp(git_submodule_url(sm2), str) != 0);
+	cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM3".url"));
+	cl_assert(strcmp(git_submodule_url(sm3), str) != 0);
+	git_config_free(cfg);
+
+	/* sync all the submodules */
+	cl_git_pass(git_submodule_foreach(g_repo, sync_one_submodule, NULL));
+
+	/* check that submodule config is updated */
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+	cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM1".url"));
+	cl_assert_equal_s(git_submodule_url(sm1), str);
+	cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM2".url"));
+	cl_assert_equal_s(git_submodule_url(sm2), str);
+	cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM3".url"));
+	cl_assert_equal_s(git_submodule_url(sm3), str);
+	git_config_free(cfg);
+}
+
+void test_submodule_modify__edit_and_save(void)
+{
+	git_submodule *sm1, *sm2;
+	char *old_url;
+	git_submodule_ignore_t old_ignore;
+	git_submodule_update_t old_update;
+	git_repository *r2;
+
+	cl_git_pass(git_submodule_lookup(&sm1, g_repo, "sm_changed_head"));
+
+	old_url = git__strdup(git_submodule_url(sm1));
+
+	/* modify properties of submodule */
+	cl_git_pass(git_submodule_set_url(sm1, SM_LIBGIT2_URL));
+	old_ignore = git_submodule_set_ignore(sm1, GIT_SUBMODULE_IGNORE_UNTRACKED);
+	old_update = git_submodule_set_update(sm1, GIT_SUBMODULE_UPDATE_REBASE);
+
+	cl_assert_equal_s(SM_LIBGIT2_URL, git_submodule_url(sm1));
+	cl_assert_equal_i(
+		(int)GIT_SUBMODULE_IGNORE_UNTRACKED, (int)git_submodule_ignore(sm1));
+	cl_assert_equal_i(
+		(int)GIT_SUBMODULE_UPDATE_REBASE, (int)git_submodule_update(sm1));
+
+	/* revert without saving (and confirm setters return old value) */
+	cl_git_pass(git_submodule_set_url(sm1, old_url));
+	cl_assert_equal_i(
+		(int)GIT_SUBMODULE_IGNORE_UNTRACKED,
+		(int)git_submodule_set_ignore(sm1, GIT_SUBMODULE_IGNORE_DEFAULT));
+	cl_assert_equal_i(
+		(int)GIT_SUBMODULE_UPDATE_REBASE,
+		(int)git_submodule_set_update(sm1, GIT_SUBMODULE_UPDATE_DEFAULT));
+
+	/* check that revert was successful */
+	cl_assert_equal_s(old_url, git_submodule_url(sm1));
+	cl_assert_equal_i((int)old_ignore, (int)git_submodule_ignore(sm1));
+	cl_assert_equal_i((int)old_update, (int)git_submodule_update(sm1));
+
+	/* modify properties of submodule (again) */
+	cl_git_pass(git_submodule_set_url(sm1, SM_LIBGIT2_URL));
+	git_submodule_set_ignore(sm1, GIT_SUBMODULE_IGNORE_UNTRACKED);
+	git_submodule_set_update(sm1, GIT_SUBMODULE_UPDATE_REBASE);
+
+	/* call save */
+	cl_git_pass(git_submodule_save(sm1));
+
+	/* attempt to "revert" values */
+	git_submodule_set_ignore(sm1, GIT_SUBMODULE_IGNORE_DEFAULT);
+	git_submodule_set_update(sm1, GIT_SUBMODULE_UPDATE_DEFAULT);
+
+	/* but ignore and update should NOT revert because the DEFAULT
+	 * should now be the newly saved value...
+	 */
+	cl_assert_equal_i(
+		(int)GIT_SUBMODULE_IGNORE_UNTRACKED, (int)git_submodule_ignore(sm1));
+	cl_assert_equal_i(
+		(int)GIT_SUBMODULE_UPDATE_REBASE, (int)git_submodule_update(sm1));
+
+	/* call reload and check that the new values are loaded */
+	cl_git_pass(git_submodule_reload(sm1));
+
+	cl_assert_equal_s(SM_LIBGIT2_URL, git_submodule_url(sm1));
+	cl_assert_equal_i(
+		(int)GIT_SUBMODULE_IGNORE_UNTRACKED, (int)git_submodule_ignore(sm1));
+	cl_assert_equal_i(
+		(int)GIT_SUBMODULE_UPDATE_REBASE, (int)git_submodule_update(sm1));
+
+	/* open a second copy of the repo and compare submodule */
+	cl_git_pass(git_repository_open(&r2, "submod2"));
+	cl_git_pass(git_submodule_lookup(&sm2, r2, "sm_changed_head"));
+
+	cl_assert_equal_s(SM_LIBGIT2_URL, git_submodule_url(sm2));
+	cl_assert_equal_i(
+		(int)GIT_SUBMODULE_IGNORE_UNTRACKED, (int)git_submodule_ignore(sm2));
+	cl_assert_equal_i(
+		(int)GIT_SUBMODULE_UPDATE_REBASE, (int)git_submodule_update(sm2));
+
+	git_repository_free(r2);
+}

tests-clar/submodule/status.c

+#include "clar_libgit2.h"
+#include "posix.h"
+#include "path.h"
+#include "submodule_helpers.h"
+
+static git_repository *g_repo = NULL;
+
+void test_submodule_status__initialize(void)
+{
+	g_repo = cl_git_sandbox_init("submod2");
+
+	cl_fixture_sandbox("submod2_target");
+	p_rename("submod2_target/.gitted", "submod2_target/.git");
+
+	/* must create submod2_target before rewrite so prettify will work */
+	rewrite_gitmodules(git_repository_workdir(g_repo));
+	p_rename("submod2/not_submodule/.gitted", "submod2/not_submodule/.git");
+}
+
+void test_submodule_status__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+	cl_fixture_cleanup("submod2_target");
+}
+
+void test_submodule_status__unchanged(void)
+{
+	/* make sure it really looks unchanged */
+}
+
+void test_submodule_status__changed(void)
+{
+	/* 4 values of GIT_SUBMODULE_IGNORE to check */
+
+	/* 6 states of change:
+	 * - none, (handled in __unchanged above)
+	 * - dirty workdir file,
+	 * - dirty index,
+	 * - moved head,
+	 * - untracked file,
+	 * - missing commits (i.e. superproject commit is ahead of submodule)
+	 */
+}
+

tests-clar/submodule/submodule_helpers.c

+#include "clar_libgit2.h"
+#include "buffer.h"
+#include "path.h"
+#include "util.h"
+#include "posix.h"
+#include "submodule_helpers.h"
+
+/* rewrite gitmodules -> .gitmodules
+ * rewrite the empty or relative urls inside each module
+ * rename the .gitted directory inside any submodule to .git
+ */
+void rewrite_gitmodules(const char *workdir)
+{
+	git_buf in_f = GIT_BUF_INIT, out_f = GIT_BUF_INIT, path = GIT_BUF_INIT;
+	FILE *in, *out;
+	char line[256];
+
+	cl_git_pass(git_buf_joinpath(&in_f, workdir, "gitmodules"));
+	cl_git_pass(git_buf_joinpath(&out_f, workdir, ".gitmodules"));
+
+	cl_assert((in  = fopen(in_f.ptr, "r")) != NULL);
+	cl_assert((out = fopen(out_f.ptr, "w")) != NULL);
+
+	while (fgets(line, sizeof(line), in) != NULL) {
+		char *scan = line;
+
+		while (*scan == ' ' || *scan == '\t') scan++;
+
+		/* rename .gitted -> .git in submodule directories */
+		if (git__prefixcmp(scan, "path =") == 0) {
+			scan += strlen("path =");
+			while (*scan == ' ') scan++;
+
+			git_buf_joinpath(&path, workdir, scan);
+			git_buf_rtrim(&path);
+			git_buf_joinpath(&path, path.ptr, ".gitted");
+
+			if (!git_buf_oom(&path) && p_access(path.ptr, F_OK) == 0) {
+				git_buf_joinpath(&out_f, workdir, scan);
+				git_buf_rtrim(&out_f);
+				git_buf_joinpath(&out_f, out_f.ptr, ".git");
+
+				if (!git_buf_oom(&out_f))
+					p_rename(path.ptr, out_f.ptr);
+			}
+		}
+
+		/* copy non-"url =" lines verbatim */
+		if (git__prefixcmp(scan, "url =") != 0) {
+			fputs(line, out);
+			continue;
+		}
+
+		/* convert relative URLs in "url =" lines */
+		scan += strlen("url =");
+		while (*scan == ' ') scan++;
+
+		if (*scan == '.') {
+			git_buf_joinpath(&path, workdir, scan);
+			git_buf_rtrim(&path);
+		} else if (!*scan || *scan == '\n') {
+			git_buf_joinpath(&path, workdir, "../testrepo.git");
+		} else {
+			fputs(line, out);
+			continue;
+		}
+
+		git_path_prettify(&path, path.ptr, NULL);
+		git_buf_putc(&path, '\n');
+		cl_assert(!git_buf_oom(&path));
+
+		fwrite(line, scan - line, sizeof(char), out);
+		fputs(path.ptr, out);
+	}
+
+	fclose(in);
+	fclose(out);
+
+	cl_must_pass(p_unlink(in_f.ptr));
+
+	git_buf_free(&in_f);
+	git_buf_free(&out_f);
+	git_buf_free(&path);
+}

tests-clar/submodule/submodule_helpers.h

+extern void rewrite_gitmodules(const char *workdir);
+