Skip to contentSkip to conversation

submodule--helper: introduce add-config subcommand

PATCH Superseded Atharva Raykar 4 participants 13 messages Jul 22, 2021 – Aug 5, 2021 1 message not in the archive

v1 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 submodule--helper: introduce add-config subcommand

Add a new "add-config" subcommand to git submodule--helper with the goal of converting part of the shell code in git-submodule.sh related to git submodule add into C code. This new subcommand sets the configuration variables of a newly added submodule, by registering the url in local git config, as well as the submodule name and path in the .gitmodules file. It also sets 'submodule.<name>.active' to "true" if the submodule path has not already been covered by any pathspec specified in 'submodule.active'.

This is meant to be a faithful conversion from shell to C, with only one minor change: A warning is emitted if no value is specified in 'submodule.active', ie, the config looks like: "[submodule] active\n", because it is an invalid configuration. It would be helpful to let the user know that the pathspec is unset, and the value of 'submodule.<name>.active' might be set to 'true' so that they can rectify their configuration and prevent future surprises (especially given that the latter variable has a higher priority than the former).

The structure of the conditional to check if we need to set the 'active' toggle looks different from the shell version -- but behaves the same. The change was made to decrease code duplication. A comment has been added to explain that only one value of 'submodule.active' is obtained to check if we need to call is_submodule_active() at all.

---

This patch depends on changes introduced in 83913dd5b6 (t7400: test failure to add submodule in tracked path, 2021-06-18), which belongs to the ar/submodule-add (2021-07-12) series[1].

This changes in this patch are no different from the one in my first submodule-add conversion series[2] which has already got some reviews before.

[1] https://lore.kernel.org/git/[email protected]/
[2] https://lore.kernel.org/git/[email protected]/

 builtin/submodule--helper.c | 125 ++++++++++++++++++++++++++++++++++++
 git-submodule.sh            |  28 +-------
 2 files changed, 126 insertions(+), 27 deletions(-)
builtin/submodule--helper.c +125 -0
index 862053c9f2..9658804d24 100644
@@ -2936,6 +2936,130 @@ static int add_clone(int argc, const char **argv, const char *prefix)
 	return 0;
 }
 
+static void config_submodule_in_gitmodules(const char *name, const char *var, const char *value)
+{
+	char *key;
+
+	if (!is_writing_gitmodules_ok())
+		die(_("please make sure that the .gitmodules file is in the working tree"));
+
+	key = xstrfmt("submodule.%s.%s", name, var);
+	config_set_in_gitmodules_file_gently(key, value);
+	free(key);
+}
+
+static void configure_added_submodule(struct add_data *add_data)
+{
+	char *key, *submod_pathspec = NULL;
+	struct child_process add_submod = CHILD_PROCESS_INIT;
+	struct child_process add_gitmodules = CHILD_PROCESS_INIT;
+	int pathspec_key_exists, activate = 0;
+
+	key = xstrfmt("submodule.%s.url", add_data->sm_name);
+	git_config_set_gently(key, add_data->realrepo);
+	free(key);
+
+	add_submod.git_cmd = 1;
+	strvec_pushl(&add_submod.args, "add",
+		     "--no-warn-embedded-repo", NULL);
+	if (add_data->force)
+		strvec_push(&add_submod.args, "--force");
+	strvec_pushl(&add_submod.args, "--", add_data->sm_path, NULL);
+
+	if (run_command(&add_submod))
+		die(_("Failed to add submodule '%s'"), add_data->sm_path);
+
+	config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path);
+	config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo);
+	if (add_data->branch)
+		config_submodule_in_gitmodules(add_data->sm_name,
+					       "branch", add_data->branch);
+
+	add_gitmodules.git_cmd = 1;
+	strvec_pushl(&add_gitmodules.args,
+		     "add", "--force", "--", ".gitmodules", NULL);
+
+	if (run_command(&add_gitmodules))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	/*
+	 * NEEDSWORK: In a multi-working-tree world this needs to be
+	 * set in the per-worktree config.
+	 */
+	pathspec_key_exists = !git_config_get_string("submodule.active",
+						     &submod_pathspec);
+	if (pathspec_key_exists && !submod_pathspec) {
+		warning(_("The submodule.active configuration exists, but the "
+			  "pathspec was unset. If the submodule is not already "
+			  "active, the value of submodule.%s.active will be "
+			  "be set to 'true'."), add_data->sm_name);
+		activate = 1;
+	}
+
+	/*
+	 * If submodule.active does not exist, or if the pathspec was unset,
+	 * we will activate this module unconditionally.
+	 *
+	 * Otherwise, we ask is_submodule_active(), which iterates
+	 * through all the values of 'submodule.active' to determine
+	 * if this module is already active.
+	 */
+	if (!pathspec_key_exists || activate ||
+	    !is_submodule_active(the_repository, add_data->sm_path)) {
+		key = xstrfmt("submodule.%s.active", add_data->sm_name);
+		git_config_set_gently(key, "true");
+		free(key);
+	}
+}
+
+static int add_config(int argc, const char **argv, const char *prefix)
+{
+	int force = 0;
+	struct add_data add_data = ADD_DATA_INIT;
+
+	struct option options[] = {
+		OPT_STRING('b', "branch", &add_data.branch,
+			   N_("branch"),
+			   N_("branch of repository to store in "
+			      "the submodule configuration")),
+		OPT_STRING(0, "url", &add_data.repo,
+			   N_("string"),
+			   N_("url to clone submodule from")),
+		OPT_STRING(0, "resolved-url", &add_data.realrepo,
+			   N_("string"),
+			   N_("url to clone the submodule from, after it has "
+			      "been dereferenced relative to parent's url, "
+			      "in the case where <url> is a relative url")),
+		OPT_STRING(0, "path", &add_data.sm_path,
+			   N_("path"),
+			   N_("where the new submodule will be cloned to")),
+		OPT_STRING(0, "name", &add_data.sm_name,
+			   N_("string"),
+			   N_("name of the new submodule")),
+		OPT__FORCE(&force, N_("allow adding an otherwise ignored submodule path"),
+			   PARSE_OPT_NOCOMPLETE),
+		OPT_END()
+	};
+
+	const char *const usage[] = {
+		N_("git submodule--helper add-config "
+		   "[--force|-f] [--branch|-b <branch>] "
+		   "--url <url> --resolved-url <resolved-url> "
+		   "--path <path> --name <name>"),
+		NULL
+	};
+
+	argc = parse_options(argc, argv, prefix, options, usage, 0);
+
+	if (argc != 0)
+		usage_with_options(usage, options);
+
+	add_data.force = !!force;
+	configure_added_submodule(&add_data);
+
+	return 0;
+}
+
 #define SUPPORT_SUPER_PREFIX (1<<0)
 
 struct cmd_struct {
@@ -2949,6 +3073,7 @@ static struct cmd_struct commands[] = {
 	{"name", module_name, 0},
 	{"clone", module_clone, 0},
 	{"add-clone", add_clone, 0},
+	{"add-config", add_config, 0},
 	{"update-module-mode", module_update_module_mode, 0},
 	{"update-clone", update_clone, 0},
 	{"ensure-core-worktree", ensure_core_worktree, 0},
git-submodule.sh +1 -27
index 053daf3724..f713cb113c 100755
@@ -242,33 +242,7 @@ cmd_add()
 	fi
 
 	git submodule--helper add-clone ${GIT_QUIET:+--quiet} ${force:+"--force"} ${progress:+"--progress"} ${branch:+--branch "$branch"} --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" ${reference:+"$reference"} ${dissociate:+"--dissociate"} ${depth:+"$depth"} || exit
-	git config submodule."$sm_name".url "$realrepo"
-
-	git add --no-warn-embedded-repo $force "$sm_path" ||
-	die "fatal: $(eval_gettext "Failed to add submodule '\$sm_path'")"
-
-	git submodule--helper config submodule."$sm_name".path "$sm_path" &&
-	git submodule--helper config submodule."$sm_name".url "$repo" &&
-	if test -n "$branch"
-	then
-		git submodule--helper config submodule."$sm_name".branch "$branch"
-	fi &&
-	git add --force .gitmodules ||
-	die "fatal: $(eval_gettext "Failed to register submodule '\$sm_path'")"
-
-	# NEEDSWORK: In a multi-working-tree world, this needs to be
-	# set in the per-worktree config.
-	if git config --get submodule.active >/dev/null
-	then
-		# If the submodule being adding isn't already covered by the
-		# current configured pathspec, set the submodule's active flag
-		if ! git submodule--helper is-active "$sm_path"
-		then
-			git config submodule."$sm_name".active "true"
-		fi
-	else
-		git config submodule."$sm_name".active "true"
-	fi
+	git submodule--helper add-config ${force:+--force} ${branch:+--branch "$branch"} --url "$repo" --resolved-url "$realrepo" --path "$sm_path" --name "$sm_name"
 }
 
 #
Signature · 1 line
2.32.0
#1 lore raw
Quoted 36 lines · Atharva Raykar

Add a new "add-config" subcommand to git submodule--helper with the goal of converting part of the shell code in git-submodule.sh related to git submodule add into C code. This new subcommand sets the configuration variables of a newly added submodule, by registering the url in local git config, as well as the submodule name and path in the .gitmodules file. It also sets 'submodule.<name>.active' to "true" if the submodule path has not already been covered by any pathspec specified in 'submodule.active'.

This is meant to be a faithful conversion from shell to C, with only one minor change: A warning is emitted if no value is specified in 'submodule.active', ie, the config looks like: "[submodule] active\n", because it is an invalid configuration. It would be helpful to let the user know that the pathspec is unset, and the value of 'submodule.<name>.active' might be set to 'true' so that they can rectify their configuration and prevent future surprises (especially given that the latter variable has a higher priority than the former).

The structure of the conditional to check if we need to set the 'active' toggle looks different from the shell version -- but behaves the same. The change was made to decrease code duplication. A comment has been added to explain that only one value of 'submodule.active' is obtained to check if we need to call is_submodule_active() at all.

---

This patch depends on changes introduced in 83913dd5b6 (t7400: test failure to add submodule in tracked path, 2021-06-18), which belongs to the ar/submodule-add (2021-07-12) series[1].

Quoted 5 lines

This changes in this patch are no different from the one in my first submodule-add conversion series[2] which has already got some reviews before.

[1] https://lore.kernel.org/git/[email protected]/
[2] https://lore.kernel.org/git/[email protected]/

I forgot to mention, you can fetch this change through:
git fetch https://github.com/tfidfwastaken/git.git submodule-helper-add-config-1

#2 lore raw
In reply to Atharva Raykar

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2949

Quoted 11 lines · Atharva Raykar
builtin/submodule--helper.c +11 -0
+static void config_submodule_in_gitmodules(const char *name, const char *var, const char *value)
+{
+	char *key;
+
+	if (!is_writing_gitmodules_ok())
+		die(_("please make sure that the .gitmodules file is in the working tree"));
+
+	key = xstrfmt("submodule.%s.%s", name, var);
+	config_set_in_gitmodules_file_gently(key, value);
+	free(key);
+}

Just a small point not per-se to do with this patch, but aren't all callers of config_set_in_gitmodules_file_gently() wanting to prefix thigs with "submodule."? Looks like its API could be simplified a bit with that xstrfmt() and free() inside that function.

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2956

Quoted 6 lines
builtin/submodule--helper.c +6 -0
+static void configure_added_submodule(struct add_data *add_data)
+{
+	char *key, *submod_pathspec = NULL;
+	struct child_process add_submod = CHILD_PROCESS_INIT;
+	struct child_process add_gitmodules = CHILD_PROCESS_INIT;
+	int pathspec_key_exists, activate = 0;

Usual style is to have different variables on different lines, unless they're closely related (like "int i, j"), so "char *key;\n char *submod[...]" in this case.

Quoted 17 lines
builtin/submodule--helper.c +17 -0
+
+	key = xstrfmt("submodule.%s.url", add_data->sm_name);
+	git_config_set_gently(key, add_data->realrepo);
+	free(key);
+
+	add_submod.git_cmd = 1;
+	strvec_pushl(&add_submod.args, "add",
+		     "--no-warn-embedded-repo", NULL);
+	if (add_data->force)
+		strvec_push(&add_submod.args, "--force");
+	strvec_pushl(&add_submod.args, "--", add_data->sm_path, NULL);
+
+	if (run_command(&add_submod))
+		die(_("Failed to add submodule '%s'"), add_data->sm_path);
+
+	config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path);
+	config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo);

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2983

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+	if (add_data->branch)
+		config_submodule_in_gitmodules(add_data->sm_name,
+					       "branch", add_data->branch);
+
+	add_gitmodules.git_cmd = 1;
+	strvec_pushl(&add_gitmodules.args,
+		     "add", "--force", "--", ".gitmodules", NULL);
+
+	if (run_command(&add_gitmodules))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);

Looks good at a glance.

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2988

Quoted 4 lines
builtin/submodule--helper.c +4 -0
+	/*
+	 * NEEDSWORK: In a multi-working-tree world this needs to be
+	 * set in the per-worktree config.
+	 */

So should we have a failing test for that scenario, or...? (Update: but read ahead...)

Quoted 26 lines
builtin/submodule--helper.c +26 -0
+static int add_config(int argc, const char **argv, const char *prefix)
+{
+	int force = 0;
+	struct add_data add_data = ADD_DATA_INIT;
+
+	struct option options[] = {
+		OPT_STRING('b', "branch", &add_data.branch,
+			   N_("branch"),
+			   N_("branch of repository to store in "
+			      "the submodule configuration")),
+		OPT_STRING(0, "url", &add_data.repo,
+			   N_("string"),
+			   N_("url to clone submodule from")),
+		OPT_STRING(0, "resolved-url", &add_data.realrepo,
+			   N_("string"),
+			   N_("url to clone the submodule from, after it has "
+			      "been dereferenced relative to parent's url, "
+			      "in the case where <url> is a relative url")),
+		OPT_STRING(0, "path", &add_data.sm_path,
+			   N_("path"),
+			   N_("where the new submodule will be cloned to")),
+		OPT_STRING(0, "name", &add_data.sm_name,
+			   N_("string"),
+			   N_("name of the new submodule")),
+		OPT__FORCE(&force, N_("allow adding an otherwise ignored submodule path"),
+			   PARSE_OPT_NOCOMPLETE),

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 3050

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+		OPT_END()
+	};
+
+	const char *const usage[] = {
+		N_("git submodule--helper add-config "
+		   "[--force|-f] [--branch|-b <branch>] "
+		   "--url <url> --resolved-url <resolved-url> "
+		   "--path <path> --name <name>"),
+		NULL
+	};

I'd say consider adding this as a "static" earlier in the file, but it's an established pattern in this file, so let's keep it.

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 3052

Quoted 1 line
builtin/submodule--helper.c +1 -0
+	argc = parse_options(argc, argv, prefix, options, usage, 0);

It's fine to omit it for a helper, but we're being non-pedantic about checking mandatory options here. Would do it in a "real" built-in, but for internal use it's fine.

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 3054

Quoted 1 line
builtin/submodule--helper.c +1 -0
+	if (argc != 0)

Style: if (!argc)

Quoted 33 lines
builtin/submodule--helper.c +9 -0
+		usage_with_options(usage, options);
+
+	add_data.force = !!force;
+	configure_added_submodule(&add_data);
+
+	return 0;
+}
+
 #define SUPPORT_SUPER_PREFIX (1<<0)
 
 struct cmd_struct {
@@ -2949,6 +3073,7 @@ static struct cmd_struct commands[] = {
 	{"name", module_name, 0},
 	{"clone", module_clone, 0},
 	{"add-clone", add_clone, 0},
+	{"add-config", add_config, 0},
 	{"update-module-mode", module_update_module_mode, 0},
 	{"update-clone", update_clone, 0},
 	{"ensure-core-worktree", ensure_core_worktree, 0},
git-submodule.sh +0 -6
index 053daf3724..f713cb113c 100755
@@ -242,33 +242,7 @@ cmd_add()
 	fi
 
 	git submodule--helper add-clone ${GIT_QUIET:+--quiet} ${force:+"--force"} ${progress:+"--progress"} ${branch:+--branch "$branch"} --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" ${reference:+"$reference"} ${dissociate:+"--dissociate"} ${depth:+"$depth"} || exit
-	git config submodule."$sm_name".url "$realrepo"
-
-	git add --no-warn-embedded-repo $force "$sm_path" ||
-	die "fatal: $(eval_gettext "Failed to add submodule '\$sm_path'")"
-
-	git submodule--helper config submodule."$sm_name".path "$sm_path" &&

git-submodule.sh cmd_add() · line 260

Quoted 10 lines
git-submodule.sh +0 -10
-	git submodule--helper config submodule."$sm_name".url "$repo" &&
-	if test -n "$branch"
-	then
-		git submodule--helper config submodule."$sm_name".branch "$branch"
-	fi &&
-	git add --force .gitmodules ||
-	die "fatal: $(eval_gettext "Failed to register submodule '\$sm_path'")"
-
-	# NEEDSWORK: In a multi-working-tree world, this needs to be
-	# set in the per-worktree config.

Ah, this is the NEEDSWORK comment, just copied to the C code...

Quoted 4 lines
git-submodule.sh +0 -4
-	if git config --get submodule.active >/dev/null
-	then
-		# If the submodule being adding isn't already covered by the
-		# current configured pathspec, set the submodule's active flag

git-submodule.sh cmd_add() · line 247

Quoted 10 lines
git-submodule.sh +1 -7
-		if ! git submodule--helper is-active "$sm_path"
-		then
-			git config submodule."$sm_name".active "true"
-		fi
-	else
-		git config submodule."$sm_name".active "true"
-	fi
+	git submodule--helper add-config ${force:+--force} ${branch:+--branch "$branch"} --url "$repo" --resolved-url "$realrepo" --path "$sm_path" --name "$sm_name"
 }
 

Very nice to have this simplified.

Would be good to split this very long line across multiple lines though...

#3 lore raw
Quoted 4 lines · Ævar Arnfjörð Bjarmason

On Thu, Jul 22 2021, Atharva Raykar wrote:

Quoted 16 lines

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2949

Quoted 11 lines
builtin/submodule--helper.c +11 -0
+static void config_submodule_in_gitmodules(const char *name, const char *var, const char *value)
+{
+	char *key;
+
+	if (!is_writing_gitmodules_ok())
+		die(_("please make sure that the .gitmodules file is in the working tree"));
+
+	key = xstrfmt("submodule.%s.%s", name, var);
+	config_set_in_gitmodules_file_gently(key, value);
+	free(key);
+}

Just a small point not per-se to do with this patch, but aren't all callers of config_set_in_gitmodules_file_gently() wanting to prefix thigs with "submodule."? Looks like its API could be simplified a bit with that xstrfmt() and free() inside that function.

Yes, you are right, all the callers prefix with "submodule.". Changing the API to what you suggested, would require some special handling in 'submodule--helper:module_config()', which will be dead code after the whole series is done, so probably a better time to change it would be during the cleanup after the conversion.

Quoted 10 lines

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2956

Quoted 6 lines
builtin/submodule--helper.c +6 -0
+static void configure_added_submodule(struct add_data *add_data)
+{
+	char *key, *submod_pathspec = NULL;
+	struct child_process add_submod = CHILD_PROCESS_INIT;
+	struct child_process add_gitmodules = CHILD_PROCESS_INIT;
+	int pathspec_key_exists, activate = 0;

Usual style is to have different variables on different lines, unless they're closely related (like "int i, j"), so "char *key;\n char *submod[...]" in this case.

Okay.

Quoted 84 lines
Quoted 17 lines
builtin/submodule--helper.c +17 -0
+
+	key = xstrfmt("submodule.%s.url", add_data->sm_name);
+	git_config_set_gently(key, add_data->realrepo);
+	free(key);
+
+	add_submod.git_cmd = 1;
+	strvec_pushl(&add_submod.args, "add",
+		     "--no-warn-embedded-repo", NULL);
+	if (add_data->force)
+		strvec_push(&add_submod.args, "--force");
+	strvec_pushl(&add_submod.args, "--", add_data->sm_path, NULL);
+
+	if (run_command(&add_submod))
+		die(_("Failed to add submodule '%s'"), add_data->sm_path);
+
+	config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path);
+	config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo);

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2983

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+	if (add_data->branch)
+		config_submodule_in_gitmodules(add_data->sm_name,
+					       "branch", add_data->branch);
+
+	add_gitmodules.git_cmd = 1;
+	strvec_pushl(&add_gitmodules.args,
+		     "add", "--force", "--", ".gitmodules", NULL);
+
+	if (run_command(&add_gitmodules))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);

Looks good at a glance.

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2988

Quoted 4 lines
builtin/submodule--helper.c +4 -0
+	/*
+	 * NEEDSWORK: In a multi-working-tree world this needs to be
+	 * set in the per-worktree config.
+	 */

So should we have a failing test for that scenario, or...? (Update: but read ahead...)

Quoted 26 lines
builtin/submodule--helper.c +26 -0
+static int add_config(int argc, const char **argv, const char *prefix)
+{
+	int force = 0;
+	struct add_data add_data = ADD_DATA_INIT;
+
+	struct option options[] = {
+		OPT_STRING('b', "branch", &add_data.branch,
+			   N_("branch"),
+			   N_("branch of repository to store in "
+			      "the submodule configuration")),
+		OPT_STRING(0, "url", &add_data.repo,
+			   N_("string"),
+			   N_("url to clone submodule from")),
+		OPT_STRING(0, "resolved-url", &add_data.realrepo,
+			   N_("string"),
+			   N_("url to clone the submodule from, after it has "
+			      "been dereferenced relative to parent's url, "
+			      "in the case where <url> is a relative url")),
+		OPT_STRING(0, "path", &add_data.sm_path,
+			   N_("path"),
+			   N_("where the new submodule will be cloned to")),
+		OPT_STRING(0, "name", &add_data.sm_name,
+			   N_("string"),
+			   N_("name of the new submodule")),
+		OPT__FORCE(&force, N_("allow adding an otherwise ignored submodule path"),
+			   PARSE_OPT_NOCOMPLETE),

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 3050

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+		OPT_END()
+	};
+
+	const char *const usage[] = {
+		N_("git submodule--helper add-config "
+		   "[--force|-f] [--branch|-b <branch>] "
+		   "--url <url> --resolved-url <resolved-url> "
+		   "--path <path> --name <name>"),
+		NULL
+	};

I'd say consider adding this as a "static" earlier in the file, but it's an established pattern in this file, so let's keep it.

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 3052

Quoted 1 line
builtin/submodule--helper.c +1 -0
+	argc = parse_options(argc, argv, prefix, options, usage, 0);

It's fine to omit it for a helper, but we're being non-pedantic about checking mandatory options here. Would do it in a "real" built-in, but for internal use it's fine.

Quoted 3 lines

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 3054

Quoted 1 line
builtin/submodule--helper.c +1 -0
+	if (argc != 0)

Style: if (!argc)

Will fix.

Quoted 63 lines
Quoted 33 lines
builtin/submodule--helper.c +8 -0
+		usage_with_options(usage, options);
+
+	add_data.force = !!force;
+	configure_added_submodule(&add_data);
+
+	return 0;
+}
+

#define SUPPORT_SUPER_PREFIX (1<<0)

struct cmd_struct {

builtin/submodule--helper.c +1 -0
@@ -2949,6 +3073,7 @@ static struct cmd_struct commands[] = {
 	{"name", module_name, 0},
 	{"clone", module_clone, 0},
 	{"add-clone", add_clone, 0},
+	{"add-config", add_config, 0},
 	{"update-module-mode", module_update_module_mode, 0},
 	{"update-clone", update_clone, 0},
 	{"ensure-core-worktree", ensure_core_worktree, 0},
git-submodule.sh +0 -6
index 053daf3724..f713cb113c 100755
@@ -242,33 +242,7 @@ cmd_add()
 	fi
 
 	git submodule--helper add-clone ${GIT_QUIET:+--quiet} ${force:+"--force"} ${progress:+"--progress"} ${branch:+--branch "$branch"} --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" ${reference:+"$reference"} ${dissociate:+"--dissociate"} ${depth:+"$depth"} || exit
-	git config submodule."$sm_name".url "$realrepo"
-
-	git add --no-warn-embedded-repo $force "$sm_path" ||
-	die "fatal: $(eval_gettext "Failed to add submodule '\$sm_path'")"
-
-	git submodule--helper config submodule."$sm_name".path "$sm_path" &&

git-submodule.sh cmd_add() · line 260

Quoted 10 lines
git-submodule.sh +0 -10
-	git submodule--helper config submodule."$sm_name".url "$repo" &&
-	if test -n "$branch"
-	then
-		git submodule--helper config submodule."$sm_name".branch "$branch"
-	fi &&
-	git add --force .gitmodules ||
-	die "fatal: $(eval_gettext "Failed to register submodule '\$sm_path'")"
-
-	# NEEDSWORK: In a multi-working-tree world, this needs to be
-	# set in the per-worktree config.

Ah, this is the NEEDSWORK comment, just copied to the C code...

Quoted 4 lines
git-submodule.sh +0 -4
-	if git config --get submodule.active >/dev/null
-	then
-		# If the submodule being adding isn't already covered by the
-		# current configured pathspec, set the submodule's active flag

git-submodule.sh cmd_add() · line 247

Quoted 10 lines
git-submodule.sh +1 -7
-		if ! git submodule--helper is-active "$sm_path"
-		then
-			git config submodule."$sm_name".active "true"
-		fi
-	else
-		git config submodule."$sm_name".active "true"
-	fi
+	git submodule--helper add-config ${force:+--force} ${branch:+--branch "$branch"} --url "$repo" --resolved-url "$realrepo" --path "$sm_path" --name "$sm_name"
 }
 

Very nice to have this simplified.

Quoted 2 lines

Would be good to split this very long line across multiple lines though...

I followed the established pattern of not splitting the lines from the previous conversions ('submodule--helper update-clone' being the exception in that file).

In this case, I felt it should be fine because a follow-up series that completes the full conversion will get rid of that line entirely.

#4 lore raw
In reply to Atharva Raykar
Quoted 10 lines · Atharva Raykar

[...]
This patch depends on changes introduced in 83913dd5b6 (t7400: test failure to add submodule in tracked path, 2021-06-18), which belongs to the ar/submodule-add (2021-07-12) series[1].

This changes in this patch are no different from the one in my first submodule-add conversion series[2] which has already got some reviews before.

[1] https://lore.kernel.org/git/[email protected]/
[2] https://lore.kernel.org/git/[email protected]/

A correction:

This patch depends on that same topic, but a different commit, which is 559e49fe5c (submodule: prefix die messages with 'fatal', 2021-07-08).

#5 lore raw
In reply to Atharva Raykar
Quoted 3 lines · Atharva Raykar

This is meant to be a faithful conversion from shell to C, with only one minor change: A warning is emitted if no value is specified in 'submodule.active', ie, the config looks like: "[submodule] active\n",

... meaning that submodule.active is *not* a boolean.

In scripted porcelain, I think we let "submodule--helper is-active" to inspect its value(s), which may end up feeding a NULL as one of the pathspec elements when calling parse_pathspec(), so this may even be a bugfix. In any case, I think "submodule--helper is-active" is where such a fix should happen and in the longer term, the code that says "if submodule.active exists, ask is-active and set submodule.*.active accordingly, otherwise activate everything" we see in this patch should be simplified to always ask is-active and let is-active worry about cases like missing submodule.active and submodule.active being valueless true, so let's not worry too much about what happens in this patch, because it needs to be cleaned up anyway after the dust settles.

Quoted 7 lines
builtin/submodule--helper.c +0 -0
index 862053c9f2..9658804d24 100644
@@ -2936,6 +2936,130 @@ static int add_clone(int argc, const char **argv, const char *prefix)
 	return 0;
 }

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2947

Quoted 10 lines
builtin/submodule--helper.c +9 -0
 
+static void config_submodule_in_gitmodules(const char *name, const char *var, const char *value)
+{
+	char *key;
+
+	if (!is_writing_gitmodules_ok())
+		die(_("please make sure that the .gitmodules file is in the working tree"));
+
+	key = xstrfmt("submodule.%s.%s", name, var);
+	config_set_in_gitmodules_file_gently(key, value);

This uses _gently() to avoid dying, but does it discard error return and hide it from our callers?

Quoted 19 lines
builtin/submodule--helper.c +19 -0
+	free(key);
+}
+
+static void configure_added_submodule(struct add_data *add_data)
+{
+	char *key, *submod_pathspec = NULL;
+	struct child_process add_submod = CHILD_PROCESS_INIT;
+	struct child_process add_gitmodules = CHILD_PROCESS_INIT;
+	int pathspec_key_exists, activate = 0;
+
+	key = xstrfmt("submodule.%s.url", add_data->sm_name);
+	git_config_set_gently(key, add_data->realrepo);
+	free(key);
+
+	add_submod.git_cmd = 1;
+	strvec_pushl(&add_submod.args, "add",
+		     "--no-warn-embedded-repo", NULL);
+	if (add_data->force)
+		strvec_push(&add_submod.args, "--force");

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2976

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+	strvec_pushl(&add_submod.args, "--", add_data->sm_path, NULL);
+
+	if (run_command(&add_submod))
+		die(_("Failed to add submodule '%s'"), add_data->sm_path);
+
+	config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path);
+	config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo);
+	if (add_data->branch)
+		config_submodule_in_gitmodules(add_data->sm_name,
+					       "branch", add_data->branch);

A failure in any of the above in the scripted version used to result in "failed to register submodule" error, but they are now ignored. Intended?

Quoted 25 lines
builtin/submodule--helper.c +25 -0
+	add_gitmodules.git_cmd = 1;
+	strvec_pushl(&add_gitmodules.args,
+		     "add", "--force", "--", ".gitmodules", NULL);
+
+	if (run_command(&add_gitmodules))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	/*
+	 * NEEDSWORK: In a multi-working-tree world this needs to be
+	 * set in the per-worktree config.
+	 */
+	pathspec_key_exists = !git_config_get_string("submodule.active",
+						     &submod_pathspec);
+	if (pathspec_key_exists && !submod_pathspec) {
+		warning(_("The submodule.active configuration exists, but the "
+			  "pathspec was unset. If the submodule is not already "
+			  "active, the value of submodule.%s.active will be "
+			  "be set to 'true'."), add_data->sm_name);
+		activate = 1;
+	}
+
+	/*
+	 * If submodule.active does not exist, or if the pathspec was unset,
+	 * we will activate this module unconditionally.
+	 *

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 3012

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+	 * Otherwise, we ask is_submodule_active(), which iterates
+	 * through all the values of 'submodule.active' to determine
+	 * if this module is already active.
+	 */
+	if (!pathspec_key_exists || activate ||
+	    !is_submodule_active(the_repository, add_data->sm_path)) {
+		key = xstrfmt("submodule.%s.active", add_data->sm_name);
+		git_config_set_gently(key, "true");
+		free(key);
+	}

This is the part I discussed earlier. I think this "optimize so that we can avoid calling is_submodule_active()" should go away in the long run. In the current code, is_submodule_active() needs to find out the value of submodule.active itself anyway, so the short-circuit is not working as an optimization.

Other than the "what happens when we see errors?" issue, the patch looks quite straight-forward rewrite from the scripted version.

Thanks.

#6 lore raw
Quoted 8 lines · Junio C Hamano
Quoted 3 lines · Atharva Raykar

This is meant to be a faithful conversion from shell to C, with only one minor change: A warning is emitted if no value is specified in 'submodule.active', ie, the config looks like: "[submodule] active\n",

... meaning that submodule.active is *not* a boolean.

Quoted 12 lines

In scripted porcelain, I think we let "submodule--helper is-active" to inspect its value(s), which may end up feeding a NULL as one of the pathspec elements when calling parse_pathspec(), so this may even be a bugfix. In any case, I think "submodule--helper is-active" is where such a fix should happen and in the longer term, the code that says "if submodule.active exists, ask is-active and set submodule.*.active accordingly, otherwise activate everything" we see in this patch should be simplified to always ask is-active and let is-active worry about cases like missing submodule.active and submodule.active being valueless true, so let's not worry too much about what happens in this patch, because it needs to be cleaned up anyway after the dust settles.

Okay, that makes sense. I'll remove the extra warning and special handling and make it a bug-for-bug conversion for now, so that the cleanup can be handled afterwards. It will probably be more fitting to have this change 'is_submodule_active()' afterwards. I'll maybe add a NEEDSWORK comment for now?

Quoted 46 lines
Quoted 7 lines
builtin/submodule--helper.c +0 -0
index 862053c9f2..9658804d24 100644
@@ -2936,6 +2936,130 @@ static int add_clone(int argc, const char **argv, const char *prefix)
 	return 0;
 }

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2947

Quoted 10 lines
builtin/submodule--helper.c +9 -0
 
+static void config_submodule_in_gitmodules(const char *name, const char *var, const char *value)
+{
+	char *key;
+
+	if (!is_writing_gitmodules_ok())
+		die(_("please make sure that the .gitmodules file is in the working tree"));
+
+	key = xstrfmt("submodule.%s.%s", name, var);
+	config_set_in_gitmodules_file_gently(key, value);

This uses _gently() to avoid dying, but does it discard error return and hide it from our callers?

Quoted 25 lines
builtin/submodule--helper.c +25 -0
+	free(key);
+}
+
+static void configure_added_submodule(struct add_data *add_data)
+{
+	char *key, *submod_pathspec = NULL;
+	struct child_process add_submod = CHILD_PROCESS_INIT;
+	struct child_process add_gitmodules = CHILD_PROCESS_INIT;
+	int pathspec_key_exists, activate = 0;
+
+	key = xstrfmt("submodule.%s.url", add_data->sm_name);
+	git_config_set_gently(key, add_data->realrepo);
+	free(key);
+
+	add_submod.git_cmd = 1;
+	strvec_pushl(&add_submod.args, "add",
+		     "--no-warn-embedded-repo", NULL);
+	if (add_data->force)
+		strvec_push(&add_submod.args, "--force");
+	strvec_pushl(&add_submod.args, "--", add_data->sm_path, NULL);
+
+	if (run_command(&add_submod))
+		die(_("Failed to add submodule '%s'"), add_data->sm_path);
+
+	config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path);
Quoted 8 lines

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2976

Quoted 4 lines
builtin/submodule--helper.c +4 -0
+	config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo);
+	if (add_data->branch)
+		config_submodule_in_gitmodules(add_data->sm_name,
+					       "branch", add_data->branch);

A failure in any of the above in the scripted version used to result in "failed to register submodule" error, but they are now ignored. Intended?

This was not intended. I think I did not notice those expressions were chained in the scripted version. I'll fix this.

Quoted 33 lines
Quoted 33 lines
builtin/submodule--helper.c +33 -0
+	add_gitmodules.git_cmd = 1;
+	strvec_pushl(&add_gitmodules.args,
+		     "add", "--force", "--", ".gitmodules", NULL);
+
+	if (run_command(&add_gitmodules))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	/*
+	 * NEEDSWORK: In a multi-working-tree world this needs to be
+	 * set in the per-worktree config.
+	 */
+	pathspec_key_exists = !git_config_get_string("submodule.active",
+						     &submod_pathspec);
+	if (pathspec_key_exists && !submod_pathspec) {
+		warning(_("The submodule.active configuration exists, but the "
+			  "pathspec was unset. If the submodule is not already "
+			  "active, the value of submodule.%s.active will be "
+			  "be set to 'true'."), add_data->sm_name);
+		activate = 1;
+	}
+
+	/*
+	 * If submodule.active does not exist, or if the pathspec was unset,
+	 * we will activate this module unconditionally.
+	 *
+	 * Otherwise, we ask is_submodule_active(), which iterates
+	 * through all the values of 'submodule.active' to determine
+	 * if this module is already active.
+	 */
+	if (!pathspec_key_exists || activate ||
+	    !is_submodule_active(the_repository, add_data->sm_path)) {
+		key = xstrfmt("submodule.%s.active", add_data->sm_name);
+		git_config_set_gently(key, "true");
Quoted 8 lines

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 3011

Quoted 2 lines
builtin/submodule--helper.c +2 -0
+		free(key);
+	}

This is the part I discussed earlier. I think this "optimize so that we can avoid calling is_submodule_active()" should go away in the long run. In the current code, is_submodule_active() needs to find out the value of submodule.active itself anyway, so the short-circuit is not working as an optimization.

Agreed.

Quoted 5 lines

Other than the "what happens when we see errors?" issue, the patch looks quite straight-forward rewrite from the scripted version.

Thanks.

#7 lore raw

PATCH v2 1/1 submodule--helper: introduce add-config subcommand

In reply to Atharva Raykar

Add a new "add-config" subcommand to git submodule--helper with the goal of converting part of the shell code in git-submodule.sh related to git submodule add into C code. This new subcommand sets the configuration variables of a newly added submodule, by registering the url in local git config, as well as the submodule name and path in the .gitmodules file. It also sets 'submodule.<name>.active' to "true" if the submodule path has not already been covered by any pathspec specified in 'submodule.active'.

This is meant to be a faithful conversion from shell to C, with only one minor change: A warning is emitted if no value is specified in 'submodule.active', ie, the config looks like: "[submodule] active\n", because it is an invalid configuration. It would be helpful to let the user know that the pathspec is unset, and the value of 'submodule.<name>.active' might be set to 'true' so that they can rectify their configuration and prevent future surprises (especially given that the latter variable has a higher priority than the former).

The structure of the conditional to check if we need to set the 'active' toggle looks different from the shell version -- but behaves the same. The change was made to decrease code duplication. A comment has been added to explain that only one value of 'submodule.active' is obtained to check if we need to call is_submodule_active() at all.

---

Changes since v1:

* Remove the extra handling for the case where submodule.active is valueless, as Junio pointed out that it is better dealt with in a cleanup patch.

* Do not discard error returns from 'config_submodule_in_gitmodules()', and also ensure that any calls to it in 'configure_added_submodule()' die on failure, like with the original shell porcelain.

* Style fixes.

 builtin/submodule--helper.c | 120 ++++++++++++++++++++++++++++++++++++
 git-submodule.sh            |  28 +--------
 2 files changed, 121 insertions(+), 27 deletions(-)
builtin/submodule--helper.c +120 -0
index 862053c9f2..60b47492cb 100644
@@ -2936,6 +2936,125 @@ static int add_clone(int argc, const char **argv, const char *prefix)
 	return 0;
 }
 
+static int config_submodule_in_gitmodules(const char *name, const char *var, const char *value)
+{
+	char *key;
+	int ret;
+
+	if (!is_writing_gitmodules_ok())
+		die(_("please make sure that the .gitmodules file is in the working tree"));
+
+	key = xstrfmt("submodule.%s.%s", name, var);
+	ret = config_set_in_gitmodules_file_gently(key, value);
+	free(key);
+
+	return ret;
+}
+
+static void configure_added_submodule(struct add_data *add_data)
+{
+	char *key;
+	char *val = NULL;
+	struct child_process add_submod = CHILD_PROCESS_INIT;
+	struct child_process add_gitmodules = CHILD_PROCESS_INIT;
+
+	key = xstrfmt("submodule.%s.url", add_data->sm_name);
+	git_config_set_gently(key, add_data->realrepo);
+	free(key);
+
+	add_submod.git_cmd = 1;
+	strvec_pushl(&add_submod.args, "add",
+		     "--no-warn-embedded-repo", NULL);
+	if (add_data->force)
+		strvec_push(&add_submod.args, "--force");
+	strvec_pushl(&add_submod.args, "--", add_data->sm_path, NULL);
+
+	if (run_command(&add_submod))
+		die(_("Failed to add submodule '%s'"), add_data->sm_path);
+
+	if (config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path) ||
+	    config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	if (add_data->branch)
+		if (config_submodule_in_gitmodules(add_data->sm_name,
+						   "branch", add_data->branch))
+			die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	add_gitmodules.git_cmd = 1;
+	strvec_pushl(&add_gitmodules.args,
+		     "add", "--force", "--", ".gitmodules", NULL);
+
+	if (run_command(&add_gitmodules))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	/*
+	 * NEEDSWORK: In a multi-working-tree world this needs to be
+	 * set in the per-worktree config.
+	 *
+	 * If submodule.active does not exist, or if the pathspec was unset,
+	 * we will activate this module unconditionally.
+	 *
+	 * Otherwise, we ask is_submodule_active(), which iterates
+	 * through all the values of 'submodule.active' to determine
+	 * if this module is already active.
+	 */
+	if (git_config_get_string("submodule.active", &val) ||
+	    !is_submodule_active(the_repository, add_data->sm_path)) {
+		key = xstrfmt("submodule.%s.active", add_data->sm_name);
+		git_config_set_gently(key, "true");
+		free(key);
+	}
+}
+
+static int add_config(int argc, const char **argv, const char *prefix)
+{
+	int force = 0;
+	struct add_data add_data = ADD_DATA_INIT;
+
+	struct option options[] = {
+		OPT_STRING('b', "branch", &add_data.branch,
+			   N_("branch"),
+			   N_("branch of repository to store in "
+			      "the submodule configuration")),
+		OPT_STRING(0, "url", &add_data.repo,
+			   N_("string"),
+			   N_("url to clone submodule from")),
+		OPT_STRING(0, "resolved-url", &add_data.realrepo,
+			   N_("string"),
+			   N_("url to clone the submodule from, after it has "
+			      "been dereferenced relative to parent's url, "
+			      "in the case where <url> is a relative url")),
+		OPT_STRING(0, "path", &add_data.sm_path,
+			   N_("path"),
+			   N_("where the new submodule will be cloned to")),
+		OPT_STRING(0, "name", &add_data.sm_name,
+			   N_("string"),
+			   N_("name of the new submodule")),
+		OPT__FORCE(&force, N_("allow adding an otherwise ignored submodule path"),
+			   PARSE_OPT_NOCOMPLETE),
+		OPT_END()
+	};
+
+	const char *const usage[] = {
+		N_("git submodule--helper add-config "
+		   "[--force|-f] [--branch|-b <branch>] "
+		   "--url <url> --resolved-url <resolved-url> "
+		   "--path <path> --name <name>"),
+		NULL
+	};
+
+	argc = parse_options(argc, argv, prefix, options, usage, 0);
+
+	if (argc)
+		usage_with_options(usage, options);
+
+	add_data.force = !!force;
+	configure_added_submodule(&add_data);
+
+	return 0;
+}
+
 #define SUPPORT_SUPER_PREFIX (1<<0)
 
 struct cmd_struct {
@@ -2949,6 +3068,7 @@ static struct cmd_struct commands[] = {
 	{"name", module_name, 0},
 	{"clone", module_clone, 0},
 	{"add-clone", add_clone, 0},
+	{"add-config", add_config, 0},
 	{"update-module-mode", module_update_module_mode, 0},
 	{"update-clone", update_clone, 0},
 	{"ensure-core-worktree", ensure_core_worktree, 0},
git-submodule.sh +1 -27
index 053daf3724..f713cb113c 100755
@@ -242,33 +242,7 @@ cmd_add()
 	fi
 
 	git submodule--helper add-clone ${GIT_QUIET:+--quiet} ${force:+"--force"} ${progress:+"--progress"} ${branch:+--branch "$branch"} --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" ${reference:+"$reference"} ${dissociate:+"--dissociate"} ${depth:+"$depth"} || exit
-	git config submodule."$sm_name".url "$realrepo"
-
-	git add --no-warn-embedded-repo $force "$sm_path" ||
-	die "fatal: $(eval_gettext "Failed to add submodule '\$sm_path'")"
-
-	git submodule--helper config submodule."$sm_name".path "$sm_path" &&
-	git submodule--helper config submodule."$sm_name".url "$repo" &&
-	if test -n "$branch"
-	then
-		git submodule--helper config submodule."$sm_name".branch "$branch"
-	fi &&
-	git add --force .gitmodules ||
-	die "fatal: $(eval_gettext "Failed to register submodule '\$sm_path'")"
-
-	# NEEDSWORK: In a multi-working-tree world, this needs to be
-	# set in the per-worktree config.
-	if git config --get submodule.active >/dev/null
-	then
-		# If the submodule being adding isn't already covered by the
-		# current configured pathspec, set the submodule's active flag
-		if ! git submodule--helper is-active "$sm_path"
-		then
-			git config submodule."$sm_name".active "true"
-		fi
-	else
-		git config submodule."$sm_name".active "true"
-	fi
+	git submodule--helper add-config ${force:+--force} ${branch:+--branch "$branch"} --url "$repo" --resolved-url "$realrepo" --path "$sm_path" --name "$sm_name"
 }
 
 #
Signature · 1 line
2.32.0
#8 lore raw

Hi Atharva,

Quoted 9 lines · Atharva Raykar

Add a new "add-config" subcommand to git submodule--helper with the goal of converting part of the shell code in git-submodule.sh related to git submodule add into C code. This new subcommand sets the configuration variables of a newly added submodule, by registering the url in local git config, as well as the submodule name and path in the .gitmodules file. It also sets 'submodule.<name>.active' to "true" if the submodule path has not already been covered by any pathspec specified in 'submodule.active'.

Quoted 9 lines

This is meant to be a faithful conversion from shell to C, with only one minor change: A warning is emitted if no value is specified in 'submodule.active', ie, the config looks like: "[submodule] active\n", because it is an invalid configuration. It would be helpful to let the user know that the pathspec is unset, and the value of 'submodule.<name>.active' might be set to 'true' so that they can rectify their configuration and prevent future surprises (especially given that the latter variable has a higher priority than the former).

v2 doesn't have the warning that this paragraph describes. So, this could be dropped.

Quoted 6 lines

[ snip ]

A comment has been
added to explain that only one value of 'submodule.active' is obtained to check if we need to call is_submodule_active() at all.

This could be me likely not understanding this properly. Anyways, where is this comment in the code? I only see a comment about how 'is_submodule_active' iterates over all values. I couldn't find any "one value" reference in it.

Quoted 73 lines

---

Changes since v1:

* Remove the extra handling for the case where submodule.active is valueless, as Junio pointed out that it is better dealt with in a cleanup patch.

* Do not discard error returns from 'config_submodule_in_gitmodules()', and also ensure that any calls to it in 'configure_added_submodule()' die on failure, like with the original shell porcelain.

* Style fixes.

  builtin/submodule--helper.c | 120 ++++++++++++++++++++++++++++++++++++
  git-submodule.sh            |  28 +--------
  2 files changed, 121 insertions(+), 27 deletions(-)
builtin/submodule--helper.c +42 -0
index 862053c9f2..60b47492cb 100644
@@ -2936,6 +2936,125 @@ static int add_clone(int argc, const char **argv, const char *prefix)
  	return 0;
  }
 
+static int config_submodule_in_gitmodules(const char *name, const char *var, const char *value)
+{
+	char *key;
+	int ret;
+
+	if (!is_writing_gitmodules_ok())
+		die(_("please make sure that the .gitmodules file is in the working tree"));
+
+	key = xstrfmt("submodule.%s.%s", name, var);
+	ret = config_set_in_gitmodules_file_gently(key, value);
+	free(key);
+
+	return ret;
+}
+
+static void configure_added_submodule(struct add_data *add_data)
+{
+	char *key;
+	char *val = NULL;
+	struct child_process add_submod = CHILD_PROCESS_INIT;
+	struct child_process add_gitmodules = CHILD_PROCESS_INIT;
+
+	key = xstrfmt("submodule.%s.url", add_data->sm_name);
+	git_config_set_gently(key, add_data->realrepo);
+	free(key);
+
+	add_submod.git_cmd = 1;
+	strvec_pushl(&add_submod.args, "add",
+		     "--no-warn-embedded-repo", NULL);
+	if (add_data->force)
+		strvec_push(&add_submod.args, "--force");
+	strvec_pushl(&add_submod.args, "--", add_data->sm_path, NULL);
+
+	if (run_command(&add_submod))
+		die(_("Failed to add submodule '%s'"), add_data->sm_path);
+
 
+	if (config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path) ||
+	    config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	if (add_data->branch)
+		if (config_submodule_in_gitmodules(add_data->sm_name,

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2991

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+						   "branch", add_data->branch))
+			die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	add_gitmodules.git_cmd = 1;
+	strvec_pushl(&add_gitmodules.args,
+		     "add", "--force", "--", ".gitmodules", NULL);
+
+	if (run_command(&add_gitmodules))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);
+

We could restructure this portion like so ...

-- 8< --

        add_gitmodules.git_cmd = 1;
        strvec_pushl(&add_gitmodules.args,
                     "add", "--force", "--", ".gitmodules", NULL);
                                                                                                                                                                                             
        if (config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path) ||
            config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo) ||
            (add_data->branch && config_submodule_in_gitmodules(add_data->sm_name,
                                                                "branch", add_data->branch)) ||
            run_command(&add_gitmodules))
                die(_("Failed to register submodule '%s'"), add_data->sm_path);

-- >8 --

.. to avoid the redundant "Failed to register submodule ..." error message. Whether the restructured version has poor readability or not is debatable, though.

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2994

Quoted 4 lines
builtin/submodule--helper.c +4 -0
+	/*
+	 * NEEDSWORK: In a multi-working-tree world this needs to be
+	 * set in the per-worktree config.
+	 *

It might be a good idea to differentiate the NEEDSWORK comment from an informative comment about the code snippet.

Also, you could add another NEEDSWORK/TODO comment regarding the change to 'is_submodule_active' which you mention before[1].

[1]: https://public-inbox.org/git/[email protected]/

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 3007

Quoted 13 lines
builtin/submodule--helper.c +13 -0
+	 * If submodule.active does not exist, or if the pathspec was unset,
+	 * we will activate this module unconditionally.
+	 *
+	 * Otherwise, we ask is_submodule_active(), which iterates
+	 * through all the values of 'submodule.active' to determine
+	 * if this module is already active.
+	 */
+	if (git_config_get_string("submodule.active", &val) ||
+	    !is_submodule_active(the_repository, add_data->sm_path)) {
+		key = xstrfmt("submodule.%s.active", add_data->sm_name);
+		git_config_set_gently(key, "true");
+		free(key);
+	}

It might be a good idea to expand this condition similar to the scripted version, to retain the following comment which seems like a useful one to keep.

Quoted 19 lines

[ snip ]

builtin/submodule--helper.c +1 -11
-	if git config --get submodule.active >/dev/null
-	then
-		# If the submodule being adding isn't already covered by the
-		# current configured pathspec, set the submodule's active flag
-		if ! git submodule--helper is-active "$sm_path"
-		then
-			git config submodule."$sm_name".active "true"
-		fi
-	else
-		git config submodule."$sm_name".active "true"
-	fi
 
+	git submodule--helper add-config ${force:+--force} ${branch:+--branch "$branch"} --url "$repo" --resolved-url "$realrepo" --path "$sm_path" --name "$sm_name"
  }
 
  #
Signature · 1 line
Sivaraam

A message that is not in the archive (sent off-list or not yet received): [email protected]

#10 lore raw
Quoted 3 lines · Atharva Raykar

(apologies for the reflowed text, seems to only happen when replying to this message?? Won't affect this response much though)

In case you're using thunderbird then you could see if the following helps:

http://kb.mozillazine.org/Plain_text_e-mail_%28Thunderbird%29#Flowed_format

Quoted 46 lines · Kaartic Sivaraam
Quoted 22 lines

Hi Atharva,

Quoted 9 lines · Atharva Raykar

Add a new "add-config" subcommand to git submodule--helper with the goal of converting part of the shell code in git-submodule.sh related to git submodule add into C code. This new subcommand sets the configuration variables of a newly added submodule, by registering the url in local git config, as well as the submodule name and path in the .gitmodules file. It also sets 'submodule.<name>.active' to "true" if the submodule path has not already been covered by any pathspec specified in 'submodule.active'.

Quoted 9 lines

This is meant to be a faithful conversion from shell to C, with only one minor change: A warning is emitted if no value is specified in 'submodule.active', ie, the config looks like: "[submodule] active\n", because it is an invalid configuration. It would be helpful to let the user know that the pathspec is unset, and the value of 'submodule.<name>.active' might be set to 'true' so that they can rectify their configuration and prevent future surprises (especially given that the latter variable has a higher priority than the former).

Quoted 2 lines

v2 doesn't have the warning that this paragraph describes. So, this could be dropped.

My bad, looks like I forgot to edit the commit message.

Quoted 11 lines
Quoted 6 lines

[ snip ]

A comment has been
added to explain that only one value of 'submodule.active' is obtained to check if we need to call is_submodule_active() at all.

This could be me likely not understanding this properly. Anyways, where is this comment in the code? I only see a comment about how 'is_submodule_active'
iterates over all values. I couldn't find any "one value" reference in it.

Looks like my comment does not explain it clearly. It would have made more sense to start the comment with "If there is no value found for submodule.active", but I think instead of modifying that comment (which is clear enough as it is), I'll make the commit message better, by removing the mention of the "we check one value".

Quoted 8 lines

It seems like the line:

if (git_config_get_string("submodule.active", &val)

makes it clear that a single string is being queried first. The larger point was about why that conditional was needed, if we were going to call 'is_submodule_active()' to retrieve the value anyway.

Ah. Now I get the idea. A rephrasing might indeed make this clear.

Quoted 33 lines
Quoted 33 lines
Quoted 6 lines

+    if (config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path) || +        config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo)) +        die(_("Failed to register submodule '%s'"), add_data->sm_path);

builtin/submodule--helper.c +3 -0
+
+    if (add_data->branch)
+        if (config_submodule_in_gitmodules(add_data->sm_name,

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2990

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+                           "branch", add_data->branch))
+            die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+    add_gitmodules.git_cmd = 1;
+    strvec_pushl(&add_gitmodules.args,
+             "add", "--force", "--", ".gitmodules", NULL);
+
+    if (run_command(&add_gitmodules))
+        die(_("Failed to register submodule '%s'"), add_data->sm_path);
+

We could restructure this portion like so ...

-- 8< --
        add_gitmodules.git_cmd = 1; strvec_pushl(&add_gitmodules.args,
                     "add", "--force", "--", ".gitmodules", NULL);

Quoted 1 line
         if (config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path) ||
             config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo) ||

            (add_data->branch && config_submodule_in_gitmodules(add_data->sm_name, "branch", add_data->branch)) || run_command(&add_gitmodules))
                die(_("Failed to register submodule '%s'"),
add_data->sm_path);
-- >8 --

Quoted 6 lines
Quoted 2 lines

.. to avoid the redundant "Failed to register submodule ..." error message. Whether the restructured version has poor readability or not is debatable, though.

Yeah, I felt the redundancy in this case was okay, I find that big conditional rather hard to read.

I tried to make it as easy to read as possible but its a really long one indeed. So, I could understand. But the redundancy bothered me a bit ;-)

Quoted 11 lines
Quoted 7 lines
Quoted 4 lines

+    /*
+     * NEEDSWORK: In a multi-working-tree world this needs to be +     * set in the per-worktree config.
+     *

It might be a good idea to differentiate the NEEDSWORK comment from an informative comment about the code snippet.

Okay. I suppose you mean give this part it's own closing delimiter and start the next line with a new multiline comment.

Yeah. I did mean this.

Quoted 49 lines

If you meant something else, do let me know.

Quoted 4 lines

Also, you could add another NEEDSWORK/TODO comment regarding the change to 'is_submodule_active' which you mention before[1].

[1]: https://public-inbox.org/git/[email protected]/

Good point. I'll add it.

Quoted 14 lines
Quoted 5 lines

+     * If submodule.active does not exist, or if the pathspec was unset, +     * we will activate this module unconditionally.
+     *
+     * Otherwise, we ask is_submodule_active(), which iterates +     * through all the values of 'submodule.active' to determine

Quoted 8 lines

+     * if this module is already active.
+     */
+    if (git_config_get_string("submodule.active", &val) || +        !is_submodule_active(the_repository, add_data->sm_path)) { +        key = xstrfmt("submodule.%s.active", add_data->sm_name); +        git_config_set_gently(key, "true");
+        free(key);
+    }

Quoted 2 lines

It might be a good idea to expand this condition similar to the scripted version, to retain the following comment which seems like a useful one to keep.

I felt that this version had less redundant code, and hence seemed more readable than the expanded conditional in shell.

For comparison this is the same code imitating the shell version:

if (!git_config_get_string("submodule.active", &var) && var) {

	/*
	 * If the submodule being added isn't already covered by the
	 * current configured pathspec, set the submodule's active flag
	 */
	if (!is_submodule_active(the_repository, info->sm_path)) {
		key = xstrfmt("submodule.%s.active", info->sm_name);
		git_config_set_gently(key, "true");
		free(key);
	}
} else {
	key = xstrfmt("submodule.%s.active", info->sm_name);
	git_config_set_gently(key, "true");
	free(key);
}
Quoted 7 lines

It repeats the string allocation and freeing, and also is a lot more code to parse mentally while reading. The shorter version that I used does not feel more "clever" to me than this either.

As for the comment, I felt that the new one I introduced (Otherwise, we ask ...) covers the same ground.

I think the comment you introduced only mentions that 'is_submodule_active' iterates over configs to determine that a submodule is active. It doesn't mention that we set the submodule's active flag if the submodule is not covered by the current configured pathspec, which is what the original tries to convey. Correct me if I missed anything.

Quoted 3 lines

I am open to reverting to the expanded conditional, but it would be nice if you could help me understand the motivation behind why it should be done.

I'm not against short-circuiting the conditional. I suggested expanding the conditional so that we get a structure similar to the scripted version. That way we could keep the original comment close to the inside conditional where it felt relevant :)

Quoted 21 lines
Quoted 20 lines
Quoted 19 lines

[ snip ]

-    if git config --get submodule.active >/dev/null
-    then
-        # If the submodule being adding isn't already covered by the -        # current configured pathspec, set the submodule's active flag -        if ! git submodule--helper is-active "$sm_path"
-        then
-            git config submodule."$sm_name".active "true"
-        fi
-    else
-        git config submodule."$sm_name".active "true"
-    fi
+    git submodule--helper add-config ${force:+--force} ${branch:+--branch "$branch"} --url "$repo" --resolved-url "$realrepo" --path "$sm_path" --name "$sm_name"
  }
    #

Signature · 1 line
Sivaraam
#11 lore raw
Quoted 9 lines · Kaartic Sivaraam
Quoted 3 lines · Atharva Raykar

(apologies for the reflowed text, seems to only happen when replying to this message?? Won't affect this response much though)

In case you're using thunderbird then you could see if the following helps:

http://kb.mozillazine.org/Plain_text_e-mail_%28Thunderbird%29#Flowed_format

Yeah, I have pretty much been following the setup that is in the git-format-patch [1] documentation. It worked fine until the last couple of days. The mailing list is now rejecting all my mails. My guess is because Thunderbird is forcing a 'Content-Transfer-Encoding: 7-bit' which I read causes problems with this list [2]. Strangely, so far, this header is added only when I send mails to [email protected], not elsewhere.
(sending this from GMail for now)

Here's the error message:
------8<------8<------8<------

<[email protected]>: host 23.128.96.18[23.128.96.18] said: 550 5.7.1
Content-Policy reject msg: Wrong MIME labeling on 8-bit character texts. BF:<H 0>; S229739AbhG2RfR (in reply to end of DATA command)

------8<------8<------8<------

I'll try fixing my mail situation today, and if I still have problems, I'll bring it up on a separate thread.

[1] https://git-scm.com/docs/git-format-patch#_approach_1_add_on
[2] https://lore.kernel.org/git/alpine.DEB.2.20.1611031554100.3108@virtualbox/

Quoted 177 lines
Quoted 46 lines · Kaartic Sivaraam
Quoted 22 lines

Hi Atharva,

Quoted 9 lines · Atharva Raykar

Add a new "add-config" subcommand to git submodule--helper with the goal of converting part of the shell code in git-submodule.sh related to git submodule add into C code. This new subcommand sets the configuration variables of a newly added submodule, by registering the url in local git config, as well as the submodule name and path in the .gitmodules file. It also sets 'submodule.<name>.active' to "true" if the submodule path has not already been covered by any pathspec specified in 'submodule.active'.

Quoted 9 lines

This is meant to be a faithful conversion from shell to C, with only one minor change: A warning is emitted if no value is specified in 'submodule.active', ie, the config looks like: "[submodule] active\n", because it is an invalid configuration. It would be helpful to let the user know that the pathspec is unset, and the value of 'submodule.<name>.active' might be set to 'true' so that they can rectify their configuration and prevent future surprises (especially given that the latter variable has a higher priority than the former).

Quoted 2 lines

v2 doesn't have the warning that this paragraph describes. So, this could be dropped.

My bad, looks like I forgot to edit the commit message.

Quoted 11 lines
Quoted 6 lines

[ snip ]

A comment has been
added to explain that only one value of 'submodule.active' is obtained to check if we need to call is_submodule_active() at all.

This could be me likely not understanding this properly. Anyways, where is this comment in the code? I only see a comment about how 'is_submodule_active'
iterates over all values. I couldn't find any "one value" reference in it.

Looks like my comment does not explain it clearly. It would have made more sense to start the comment with "If there is no value found for submodule.active", but I think instead of modifying that comment (which is clear enough as it is), I'll make the commit message better, by removing the mention of the "we check one value".

Quoted 8 lines

It seems like the line:

if (git_config_get_string("submodule.active", &val)

makes it clear that a single string is being queried first. The larger point was about why that conditional was needed, if we were going to call 'is_submodule_active()' to retrieve the value anyway.

Ah. Now I get the idea. A rephrasing might indeed make this clear.

Quoted 33 lines
Quoted 33 lines
Quoted 6 lines
builtin/submodule--helper.c +6 -0
+    if (config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path) ||
+        config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo))
+        die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+    if (add_data->branch)
+        if (config_submodule_in_gitmodules(add_data->sm_name,

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2990

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+                           "branch", add_data->branch))
+            die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+    add_gitmodules.git_cmd = 1;
+    strvec_pushl(&add_gitmodules.args,
+             "add", "--force", "--", ".gitmodules", NULL);
+
+    if (run_command(&add_gitmodules))
+        die(_("Failed to register submodule '%s'"), add_data->sm_path);
+

We could restructure this portion like so ...

-- 8< --

         add_gitmodules.git_cmd = 1;
         strvec_pushl(&add_gitmodules.args,
                      "add", "--force", "--", ".gitmodules", NULL);
Quoted 1 line
         if (config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path) ||
             config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo) ||
             (add_data->branch && config_submodule_in_gitmodules(add_data->sm_name,
                                                                 "branch", add_data->branch)) ||
             run_command(&add_gitmodules))
                 die(_("Failed to register submodule '%s'"),

add_data->sm_path);
-- >8 --

Quoted 6 lines
Quoted 2 lines

.. to avoid the redundant "Failed to register submodule ..." error message. Whether the restructured version has poor readability or not is debatable, though.

Yeah, I felt the redundancy in this case was okay, I find that big conditional rather hard to read.

I tried to make it as easy to read as possible but its a really long one indeed. So, I could understand. But the redundancy bothered me a bit ;-)

Quoted 11 lines
Quoted 7 lines

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2994

Quoted 4 lines
builtin/submodule--helper.c +4 -0
+    /*
+     * NEEDSWORK: In a multi-working-tree world this needs to be
+     * set in the per-worktree config.
+     *

It might be a good idea to differentiate the NEEDSWORK comment from an informative comment about the code snippet.

Okay. I suppose you mean give this part it's own closing delimiter and start the next line with a new multiline comment.

Yeah. I did mean this.

Quoted 49 lines

If you meant something else, do let me know.

Quoted 4 lines

Also, you could add another NEEDSWORK/TODO comment regarding the change to 'is_submodule_active' which you mention before[1].

[1]: https://public-inbox.org/git/[email protected]/

Good point. I'll add it.

Quoted 14 lines

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 3007

Quoted 13 lines
builtin/submodule--helper.c +13 -0
+     * If submodule.active does not exist, or if the pathspec was unset,
+     * we will activate this module unconditionally.
+     *
+     * Otherwise, we ask is_submodule_active(), which iterates
+     * through all the values of 'submodule.active' to determine
+     * if this module is already active.
+     */
+    if (git_config_get_string("submodule.active", &val) ||
+        !is_submodule_active(the_repository, add_data->sm_path)) {
+        key = xstrfmt("submodule.%s.active", add_data->sm_name);
+        git_config_set_gently(key, "true");
+        free(key);
+    }
Quoted 2 lines

It might be a good idea to expand this condition similar to the scripted version, to retain the following comment which seems like a useful one to keep.

I felt that this version had less redundant code, and hence seemed more readable than the expanded conditional in shell.

For comparison this is the same code imitating the shell version:

if (!git_config_get_string("submodule.active", &var) && var) {

      /*
       * If the submodule being added isn't already covered by the
       * current configured pathspec, set the submodule's active flag
       */
      if (!is_submodule_active(the_repository, info->sm_path)) {
              key = xstrfmt("submodule.%s.active", info->sm_name);
              git_config_set_gently(key, "true");
              free(key);
      }
} else {
      key = xstrfmt("submodule.%s.active", info->sm_name);
      git_config_set_gently(key, "true");
      free(key);
}
Quoted 7 lines

It repeats the string allocation and freeing, and also is a lot more code to parse mentally while reading. The shorter version that I used does not feel more "clever" to me than this either.

As for the comment, I felt that the new one I introduced (Otherwise, we ask ...) covers the same ground.

I think the comment you introduced only mentions that 'is_submodule_active' iterates over configs to determine that a submodule is active. It doesn't mention that we set the submodule's active flag if the submodule is not covered by the current configured pathspec, which is what the original tries to convey. Correct me if I missed anything.

Quoted 7 lines
Quoted 3 lines

I am open to reverting to the expanded conditional, but it would be nice if you could help me understand the motivation behind why it should be done.

I'm not against short-circuiting the conditional. I suggested expanding the conditional so that we get a structure similar to the scripted version. That way we could keep the original comment close to the inside conditional where it felt relevant :)

Ah okay, so the reason is so that we could keep the structure similar to retain the
comment? Okay, I'll change that.

Quoted 25 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines

[ snip ]

git-submodule.sh +0 -10
-    if git config --get submodule.active >/dev/null
-    then
-        # If the submodule being adding isn't already covered by the
-        # current configured pathspec, set the submodule's active flag
-        if ! git submodule--helper is-active "$sm_path"
-        then
-            git config submodule."$sm_name".active "true"
-        fi
-    else
-        git config submodule."$sm_name".active "true"
Quoted 9 lines
Quoted 8 lines
Quoted 7 lines
(quoted diff) +1 -1
-    fi
+    git submodule--helper add-config ${force:+--force}

${branch:+--branch "$branch"} --url "$repo" --resolved-url "$realrepo" --path "$sm_path" --name "$sm_name"
}

     #

--
Sivaraam

#12 lore raw

PATCH v3 1/1 submodule--helper: introduce add-config subcommand

In reply to Atharva Raykar

Add a new "add-config" subcommand to git submodule--helper with the goal of converting part of the shell code in git-submodule.sh related to git submodule add into C code. This new subcommand sets the configuration variables of a newly added submodule, by registering the url in local git config, as well as the submodule name and path in the .gitmodules file. It also sets 'submodule.<name>.active' to "true" if the submodule path has not already been covered by any pathspec specified in 'submodule.active'.

This is meant to be a faithful conversion from shell to C, although we add comments to areas that could be improved in future patches, after the conversion has settled.

---

Changes since v2:

* Change the commit message, which erroneously still spoke about a warning that has since been removed.

* Change the structure of the code that checks if a submodule is active, so that it more closely resembles the conditional in the original shell version, and preserves the original comments.

* Add NEEDSWORK comments, one to state the future intention of removing the check for 'submodule.active' before anyway calling is_submodule_active(). The other comment is to state the intention of adding a warning in a future patch when 'is_submodule_active()' reads a valueless 'submodule.active'.

Fetch-it-via:
git fetch https://github.com/tfidfwastaken/git.git submodule-helper-add-config-3

 builtin/submodule--helper.c | 128 ++++++++++++++++++++++++++++++++++++
 git-submodule.sh            |  28 +-------
 submodule.c                 |   5 ++
 3 files changed, 134 insertions(+), 27 deletions(-)
builtin/submodule--helper.c +128 -0
index 862053c9f2..791ceeb63e 100644
@@ -2936,6 +2936,133 @@ static int add_clone(int argc, const char **argv, const char *prefix)
 	return 0;
 }
 
+static int config_submodule_in_gitmodules(const char *name, const char *var, const char *value)
+{
+	char *key;
+	int ret;
+
+	if (!is_writing_gitmodules_ok())
+		die(_("please make sure that the .gitmodules file is in the working tree"));
+
+	key = xstrfmt("submodule.%s.%s", name, var);
+	ret = config_set_in_gitmodules_file_gently(key, value);
+	free(key);
+
+	return ret;
+}
+
+static void configure_added_submodule(struct add_data *add_data)
+{
+	char *key;
+	char *val = NULL;
+	struct child_process add_submod = CHILD_PROCESS_INIT;
+	struct child_process add_gitmodules = CHILD_PROCESS_INIT;
+
+	key = xstrfmt("submodule.%s.url", add_data->sm_name);
+	git_config_set_gently(key, add_data->realrepo);
+	free(key);
+
+	add_submod.git_cmd = 1;
+	strvec_pushl(&add_submod.args, "add",
+		     "--no-warn-embedded-repo", NULL);
+	if (add_data->force)
+		strvec_push(&add_submod.args, "--force");
+	strvec_pushl(&add_submod.args, "--", add_data->sm_path, NULL);
+
+	if (run_command(&add_submod))
+		die(_("Failed to add submodule '%s'"), add_data->sm_path);
+
+	if (config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path) ||
+	    config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	if (add_data->branch)
+		if (config_submodule_in_gitmodules(add_data->sm_name,
+						   "branch", add_data->branch))
+			die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	add_gitmodules.git_cmd = 1;
+	strvec_pushl(&add_gitmodules.args,
+		     "add", "--force", "--", ".gitmodules", NULL);
+
+	if (run_command(&add_gitmodules))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	/*
+	 * NEEDSWORK: In a multi-working-tree world this needs to be
+	 * set in the per-worktree config.
+	 */
+	/*
+	 * NEEDSWORK: In the longer run, we need to get rid of this
+	 * pattern of querying "submodule.active" before calling
+	 * is_submodule_active(), since that function needs to find
+	 * out the value of "submodule.active" again anyway.
+	 */
+	if (!git_config_get_string("submodule.active", &val) && val) {
+		/*
+		 * If the submodule being added isn't already covered by the
+		 * current configured pathspec, set the submodule's active flag
+		 */
+		if (!is_submodule_active(the_repository, add_data->sm_path)) {
+			key = xstrfmt("submodule.%s.active", add_data->sm_name);
+			git_config_set_gently(key, "true");
+			free(key);
+		}
+	} else {
+		key = xstrfmt("submodule.%s.active", add_data->sm_name);
+		git_config_set_gently(key, "true");
+		free(key);
+	}
+}
+
+static int add_config(int argc, const char **argv, const char *prefix)
+{
+	int force = 0;
+	struct add_data add_data = ADD_DATA_INIT;
+
+	struct option options[] = {
+		OPT_STRING('b', "branch", &add_data.branch,
+			   N_("branch"),
+			   N_("branch of repository to store in "
+			      "the submodule configuration")),
+		OPT_STRING(0, "url", &add_data.repo,
+			   N_("string"),
+			   N_("url to clone submodule from")),
+		OPT_STRING(0, "resolved-url", &add_data.realrepo,
+			   N_("string"),
+			   N_("url to clone the submodule from, after it has "
+			      "been dereferenced relative to parent's url, "
+			      "in the case where <url> is a relative url")),
+		OPT_STRING(0, "path", &add_data.sm_path,
+			   N_("path"),
+			   N_("where the new submodule will be cloned to")),
+		OPT_STRING(0, "name", &add_data.sm_name,
+			   N_("string"),
+			   N_("name of the new submodule")),
+		OPT__FORCE(&force, N_("allow adding an otherwise ignored submodule path"),
+			   PARSE_OPT_NOCOMPLETE),
+		OPT_END()
+	};
+
+	const char *const usage[] = {
+		N_("git submodule--helper add-config "
+		   "[--force|-f] [--branch|-b <branch>] "
+		   "--url <url> --resolved-url <resolved-url> "
+		   "--path <path> --name <name>"),
+		NULL
+	};
+
+	argc = parse_options(argc, argv, prefix, options, usage, 0);
+
+	if (argc)
+		usage_with_options(usage, options);
+
+	add_data.force = !!force;
+	configure_added_submodule(&add_data);
+
+	return 0;
+}
+
 #define SUPPORT_SUPER_PREFIX (1<<0)
 
 struct cmd_struct {
@@ -2949,6 +3076,7 @@ static struct cmd_struct commands[] = {
 	{"name", module_name, 0},
 	{"clone", module_clone, 0},
 	{"add-clone", add_clone, 0},
+	{"add-config", add_config, 0},
 	{"update-module-mode", module_update_module_mode, 0},
 	{"update-clone", update_clone, 0},
 	{"ensure-core-worktree", ensure_core_worktree, 0},
git-submodule.sh +1 -27
index 053daf3724..f713cb113c 100755
@@ -242,33 +242,7 @@ cmd_add()
 	fi
 
 	git submodule--helper add-clone ${GIT_QUIET:+--quiet} ${force:+"--force"} ${progress:+"--progress"} ${branch:+--branch "$branch"} --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" ${reference:+"$reference"} ${dissociate:+"--dissociate"} ${depth:+"$depth"} || exit
-	git config submodule."$sm_name".url "$realrepo"
-
-	git add --no-warn-embedded-repo $force "$sm_path" ||
-	die "fatal: $(eval_gettext "Failed to add submodule '\$sm_path'")"
-
-	git submodule--helper config submodule."$sm_name".path "$sm_path" &&
-	git submodule--helper config submodule."$sm_name".url "$repo" &&
-	if test -n "$branch"
-	then
-		git submodule--helper config submodule."$sm_name".branch "$branch"
-	fi &&
-	git add --force .gitmodules ||
-	die "fatal: $(eval_gettext "Failed to register submodule '\$sm_path'")"
-
-	# NEEDSWORK: In a multi-working-tree world, this needs to be
-	# set in the per-worktree config.
-	if git config --get submodule.active >/dev/null
-	then
-		# If the submodule being adding isn't already covered by the
-		# current configured pathspec, set the submodule's active flag
-		if ! git submodule--helper is-active "$sm_path"
-		then
-			git config submodule."$sm_name".active "true"
-		fi
-	else
-		git config submodule."$sm_name".active "true"
-	fi
+	git submodule--helper add-config ${force:+--force} ${branch:+--branch "$branch"} --url "$repo" --resolved-url "$realrepo" --path "$sm_path" --name "$sm_name"
 }
 
 #
submodule.c +5 -0
index 0b1d9c1dde..8577667773 100644
@@ -237,6 +237,11 @@ int option_parse_recurse_submodules_worktree_updater(const struct option *opt,
 /*
  * Determine if a submodule has been initialized at a given 'path'
  */
+/*
+ * NEEDSWORK: Emit a warning if submodule.active exists, but is valueless,
+ * ie, the config looks like: "[submodule] active\n".
+ * Since that is an invalid pathspec, we should inform the user.
+ */
 int is_submodule_active(struct repository *repo, const char *path)
 {
 	int ret = 0;
Signature · 1 line
2.32.0
#13 lore raw
Quoted 13 lines · Atharva Raykar

Add a new "add-config" subcommand to git submodule--helper with the goal of converting part of the shell code in git-submodule.sh related to git submodule add into C code. This new subcommand sets the configuration variables of a newly added submodule, by registering the url in local git config, as well as the submodule name and path in the .gitmodules file. It also sets 'submodule.<name>.active' to "true" if the submodule path has not already been covered by any pathspec specified in 'submodule.active'.

This is meant to be a faithful conversion from shell to C, although we add comments to areas that could be improved in future patches, after the conversion has settled.

Quoted 7 lines

---

The v3 mostly looks good to me. Just one style nit:

Quoted 22 lines

[ ... ]

builtin/submodule--helper.c +20 -0
+static void configure_added_submodule(struct add_data *add_data)
+{
+	char *key;
+	char *val = NULL;
+	struct child_process add_submod = CHILD_PROCESS_INIT;
+	struct child_process add_gitmodules = CHILD_PROCESS_INIT;
+
+	key = xstrfmt("submodule.%s.url", add_data->sm_name);
+	git_config_set_gently(key, add_data->realrepo);
+	free(key);
+
+	add_submod.git_cmd = 1;
+	strvec_pushl(&add_submod.args, "add",
+		     "--no-warn-embedded-repo", NULL);
+	if (add_data->force)
+		strvec_push(&add_submod.args, "--force");
+	strvec_pushl(&add_submod.args, "--", add_data->sm_path, NULL);
+
+	if (run_command(&add_submod))
+		die(_("Failed to add submodule '%s'"), add_data->sm_path);

builtin/submodule--helper.c static int add_clone(int argc, const char **argv, const char *prefix) · line 2983

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+
+	if (config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path) ||
+	    config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo))
+		die(_("Failed to register submodule '%s'"), add_data->sm_path);
+
+	if (add_data->branch)
+		if (config_submodule_in_gitmodules(add_data->sm_name,
+						   "branch", add_data->branch))
+			die(_("Failed to register submodule '%s'"), add_data->sm_path);
+

As the body of if(add->branch) has a nested if in it and totally spans 3 lines, it might be a good idea to wrap it in braces like so:

        if (add_data->branch) {
                if (config_submodule_in_gitmodules(add_data->sm_name,
                                                   "branch", add_data->branch))
                        die(_("Failed to register submodule '%s'"), add_data->sm_path);
        }

... or collapse both conditionals into a single if like so:

        if (add_data->branch &&
            config_submodule_in_gitmodules(add_data->sm_name, "branch", add_data->branch))
                die(_("Failed to register submodule '%s'"), add_data->sm_path);
Signature · 1 line
Sivaraam