Skip to contentSkip to conversation

submodule: introduce add-clone helper for submodule add

PATCH Superseded Atharva Raykar 3 participants 11 messages May 28, 2021 – Jun 4, 2021

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 submodule: introduce add-clone helper for submodule add

Convert the the shell code that performs the cloning of the repository that is to be added, and checks out to the appropriate branch.

This is meant to be a faithful conversion that leaves the behaviour of 'submodule add' unchanged. The only minor change is that if a submodule name has been supplied with a name that clashes with a local submodule, the message shown to the user ("A git directory for 'foo' is found locally...") is prepended with "error" for clarity.

---

This is part of a series of changes that will result in all of 'submodule add' being converted to C, which is a more familiar language for Git developers, and paves the way to improve performance and portability.

I have made this patch based on Shourya's patch[1]. I have decided to send the changes in smaller, more reviewable parts. The add-clone subcommand of submodule--helper is an intermediate change, while I work on translating all of the code. So in the next few patches, this helper subcommand is likely to be removed as its functionality would be invoked from the C code itself.

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

 builtin/submodule--helper.c | 221 ++++++++++++++++++++++++++++++++++++
 git-submodule.sh            |  38 +------
 2 files changed, 222 insertions(+), 37 deletions(-)
builtin/submodule--helper.c +221 -0
index d55f6262e9..39a844b0b1 100644
@@ -2745,6 +2745,226 @@ static int module_set_branch(int argc, const char **argv, const char *prefix)
 	return !!ret;
 }
 
+struct add_data {
+	const char *prefix;
+	const char *branch;
+	const char *reference_path;
+	const char *sm_path;
+	const char *sm_name;
+	const char *repo;
+	const char *realrepo;
+	int depth;
+	unsigned int force: 1;
+	unsigned int quiet: 1;
+	unsigned int progress: 1;
+	unsigned int dissociate: 1;
+};
+#define ADD_DATA_INIT { 0 }
+
+static char *parse_token(char **begin, const char *end)
+{
+	int size;
+	char *token, *pos = *begin;
+	while (pos != end && (*pos != ' ' && *pos != '\t' && *pos != '\n'))
+		pos++;
+	size = pos - *begin;
+	token = xstrndup(*begin, size);
+	*begin = pos + 1;
+	return token;
+}
+
+static char *get_next_line(char *const begin, const char *const end)
+{
+	char *pos = begin;
+	while (pos != end && *pos++ != '\n');
+	return pos;
+}
+
+static void show_fetch_remotes(FILE *output, const char *sm_name, const char *git_dir_path)
+{
+	struct child_process cp_remote = CHILD_PROCESS_INIT;
+	struct strbuf sb_remote_out = STRBUF_INIT;
+
+	cp_remote.git_cmd = 1;
+	strvec_pushf(&cp_remote.env_array,
+		     "GIT_DIR=%s", git_dir_path);
+	strvec_push(&cp_remote.env_array, "GIT_WORK_TREE=.");
+	strvec_pushl(&cp_remote.args, "remote", "-v", NULL);
+	if (!capture_command(&cp_remote, &sb_remote_out, 0)) {
+		char *next_line, *name, *url, *tail;
+		char *begin = sb_remote_out.buf;
+		char *end = sb_remote_out.buf + sb_remote_out.len;
+		while (begin != end &&
+		       (next_line = get_next_line(begin, end))) {
+			name = parse_token(&begin, next_line);
+			url = parse_token(&begin, next_line);
+			tail = parse_token(&begin, next_line);
+			if (!memcmp(tail, "(fetch)", 7))
+				fprintf(output, "  %s\t%s\n", name, url);
+			free(url);
+			free(name);
+			free(tail);
+		}
+	}
+
+	strbuf_release(&sb_remote_out);
+}
+
+static int add_submodule(const struct add_data *info)
+{
+	char *submod_gitdir_path;
+	/* perhaps the path already exists and is already a git repo, else clone it */
+	if (is_directory(info->sm_path)) {
+		printf("sm_path=%s\n", info->sm_path);
+		submod_gitdir_path = xstrfmt("%s/.git", info->sm_path);
+		if (is_directory(submod_gitdir_path) || file_exists(submod_gitdir_path))
+			printf(_("Adding existing path at '%s' to index\n"),
+			       info->sm_path);
+		else
+			die(_("'%s' already exists and is not a valid git repo"),
+			    info->sm_path);
+		free(submod_gitdir_path);
+	} else {
+		struct strvec clone_args = STRVEC_INIT;
+		struct child_process cp = CHILD_PROCESS_INIT;
+		submod_gitdir_path = xstrfmt(".git/modules/%s", info->sm_name);
+
+		if (is_directory(submod_gitdir_path)) {
+			if (!info->force) {
+				error(_("A git directory for '%s' is found "
+					"locally with remote(s):"), info->sm_name);
+				show_fetch_remotes(stderr, info->sm_name,
+						   submod_gitdir_path);
+				fprintf(stderr,
+					_("If you want to reuse this local git "
+					  "directory instead of cloning again from\n"
+					  "  %s\n"
+					  "use the '--force' option. If the local git "
+					  "directory is not the correct repo\n"
+					  "or if you are unsure what this means, choose "
+					  "another name with the '--name' option.\n"),
+					info->realrepo);
+				free(submod_gitdir_path);
+				return 1;
+			} else {
+				printf(_("Reactivating local git directory for "
+					 "submodule '%s'\n"), info->sm_name);
+			}
+		}
+		free(submod_gitdir_path);
+
+		strvec_push(&clone_args, "clone");
+
+		if (info->quiet)
+			strvec_push(&clone_args, "--quiet");
+
+		if (info->progress)
+			strvec_push(&clone_args, "--progress");
+
+		if (info->prefix)
+			strvec_pushl(&clone_args, "--prefix", info->prefix, NULL);
+
+		strvec_pushl(&clone_args, "--path", info->sm_path, "--name",
+			     info->sm_name, "--url", info->realrepo, NULL);
+
+		if (info->reference_path)
+			strvec_pushl(&clone_args, "--reference",
+				     info->reference_path, NULL);
+
+		if (info->dissociate)
+			strvec_push(&clone_args, "--dissociate");
+
+		if (info->depth >= 0)
+			strvec_pushf(&clone_args, "--depth=%d", info->depth);
+
+		if (module_clone(clone_args.nr, clone_args.v, info->prefix)) {
+			strvec_clear(&clone_args);
+			return -1;
+		}
+		strvec_clear(&clone_args);
+
+		prepare_submodule_repo_env(&cp.env_array);
+		cp.git_cmd = 1;
+		cp.dir = info->sm_path;
+		strvec_pushl(&cp.args, "checkout", "-f", "-q", NULL);
+
+		if (info->branch) {
+			strvec_pushl(&cp.args, "-B", info->branch, NULL);
+			strvec_pushf(&cp.args, "origin/%s", info->branch);
+		}
+
+		if (run_command(&cp))
+			die(_("unable to checkout submodule '%s'"), info->sm_path);
+	}
+	return 0;
+}
+
+static int add_clone(int argc, const char **argv, const char *prefix)
+{
+	const char *branch = NULL, *sm_path = NULL;
+	const char *wt_prefix = NULL, *realrepo = NULL;
+	const char *reference = NULL, *sm_name = NULL;
+	int force = 0, quiet = 0, dissociate = 0, depth = -1, progress = 0;
+	struct add_data info = ADD_DATA_INIT;
+
+	struct option options[] = {
+		OPT_STRING('b', "branch", &branch,
+			   N_("branch"),
+			   N_("branch of repository to checkout on cloning")),
+		OPT_STRING(0, "prefix", &wt_prefix,
+			   N_("path"),
+			   N_("alternative anchor for relative paths")),
+		OPT_STRING(0, "path", &sm_path,
+			   N_("path"),
+			   N_("where the new submodule will be cloned to")),
+		OPT_STRING(0, "name", &sm_name,
+			   N_("string"),
+			   N_("name of the new submodule")),
+		OPT_STRING(0, "url", &realrepo,
+			   N_("string"),
+			   N_("url where to clone the submodule from")),
+		OPT_STRING(0, "reference", &reference,
+			   N_("repo"),
+			   N_("reference repository")),
+		OPT_BOOL(0, "dissociate", &dissociate,
+			   N_("use --reference only while cloning")),
+		OPT_INTEGER(0, "depth", &depth,
+			    N_("depth for shallow clones")),
+		OPT_BOOL(0, "progress", &progress,
+			   N_("force cloning progress")),
+		OPT_BOOL('f', "force", &force,
+			 N_("allow adding an otherwise ignored submodule path")),
+		OPT__QUIET(&quiet, "Suppress output for cloning a submodule"),
+		OPT_END()
+	};
+
+	const char *const usage[] = {
+		N_("git submodule--helper clone [--prefix=<path>] [--quiet] [--force] "
+		   "[--reference <repository>] [--depth <depth>] [-b|--branch <branch>]"
+		   "--url <url> --path <path> --name <name>"),
+		NULL
+	};
+
+	argc = parse_options(argc, argv, prefix, options, usage, 0);
+
+	info.prefix = prefix;
+	info.sm_name = sm_name;
+	info.sm_path = sm_path;
+	info.realrepo = realrepo;
+	info.reference_path = reference;
+	info.branch = branch;
+	info.depth = depth;
+	info.progress = !!progress;
+	info.dissociate = !!dissociate;
+	info.force = !!force;
+	info.quiet = !!quiet;
+
+	if (add_submodule(&info))
+		return 1;
+
+	return 0;
+}
+
 #define SUPPORT_SUPER_PREFIX (1<<0)
 
 struct cmd_struct {
@@ -2757,6 +2977,7 @@ static struct cmd_struct commands[] = {
 	{"list", module_list, 0},
 	{"name", module_name, 0},
 	{"clone", module_clone, 0},
+	{"add-clone", add_clone, 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 -37
index 4678378424..f71e1e5495 100755
@@ -241,43 +241,7 @@ cmd_add()
 		die "$(eval_gettext "'$sm_name' is not a valid submodule name")"
 	fi
 
-	# perhaps the path exists and is already a git repo, else clone it
-	if test -e "$sm_path"
-	then
-		if test -d "$sm_path"/.git || test -f "$sm_path"/.git
-		then
-			eval_gettextln "Adding existing repo at '\$sm_path' to the index"
-		else
-			die "$(eval_gettext "'\$sm_path' already exists and is not a valid git repo")"
-		fi
-
-	else
-		if test -d ".git/modules/$sm_name"
-		then
-			if test -z "$force"
-			then
-				eval_gettextln >&2 "A git directory for '\$sm_name' is found locally with remote(s):"
-				GIT_DIR=".git/modules/$sm_name" GIT_WORK_TREE=. git remote -v | grep '(fetch)' | sed -e s,^,"  ", -e s,' (fetch)',, >&2
-				die "$(eval_gettextln "\
-If you want to reuse this local git directory instead of cloning again from
-  \$realrepo
-use the '--force' option. If the local git directory is not the correct repo
-or you are unsure what this means choose another name with the '--name' option.")"
-			else
-				eval_gettextln "Reactivating local git directory for submodule '\$sm_name'."
-			fi
-		fi
-		git submodule--helper clone ${GIT_QUIET:+--quiet} ${progress:+"--progress"} --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" ${reference:+"$reference"} ${dissociate:+"--dissociate"} ${depth:+"$depth"} || exit
-		(
-			sanitize_submodule_env
-			cd "$sm_path" &&
-			# ash fails to wordsplit ${branch:+-b "$branch"...}
-			case "$branch" in
-			'') git checkout -f -q ;;
-			?*) git checkout -f -q -B "$branch" "origin/$branch" ;;
-			esac
-		) || die "$(eval_gettext "Unable to checkout submodule '\$sm_path'")"
-	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" ||
Signature · 1 line
2.31.1
#1 lore raw
Quoted 2 lines · Atharva Raykar

Convert the the shell code that performs the cloning of the repository that is

s/the the/the/

Quoted 1 line

to be added, and checks out to the appropriate branch.

Something a bit more explicit might make things easier to understand. For example:

"Let's add a new "add-clone" 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 clones the repository that is to be added, and checks out to the appropriate branch."

Then a simpler title could be:

"submodule--helper: introduce add-clone subcommand"

Quoted 5 lines

This is meant to be a faithful conversion that leaves the behaviour of 'submodule add' unchanged. The only minor change is that if a submodule name has been supplied with a name that clashes with a local submodule, the message shown to the user ("A git directory for 'foo' is found locally...") is prepended with "error" for clarity.

Good.

Quoted 11 lines

---

This is part of a series of changes that will result in all of 'submodule add' being converted to C, which is a more familiar language for Git developers, and paves the way to improve performance and portability.

Quoted 5 lines

I have made this patch based on Shourya's patch[1]. I have decided to send the changes in smaller, more reviewable parts. The add-clone subcommand of submodule--helper is an intermediate change, while I work on translating all of the code. So in the next few patches, this helper subcommand is likely to be removed as its functionality would be invoked from the C code itself.

It might be a good idea to let us know how many such new subcommands you'd like to introduce before removing them.

Anyway I think it's a good idea to send changes in smaller, more easily reviewable parts. Hopefully this way more work will end up being merged.

Quoted 51 lines

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

 builtin/submodule--helper.c | 221 ++++++++++++++++++++++++++++++++++++
 git-submodule.sh            |  38 +------
 2 files changed, 222 insertions(+), 37 deletions(-)
builtin/submodule--helper.c +37 -0
index d55f6262e9..39a844b0b1 100644
@@ -2745,6 +2745,226 @@ static int module_set_branch(int argc, const char **argv, const char *prefix)
        return !!ret;
 }
 
+struct add_data {
+       const char *prefix;
+       const char *branch;
+       const char *reference_path;
+       const char *sm_path;
+       const char *sm_name;
+       const char *repo;
+       const char *realrepo;
+       int depth;
+       unsigned int force: 1;
+       unsigned int quiet: 1;
+       unsigned int progress: 1;
+       unsigned int dissociate: 1;
+};
+#define ADD_DATA_INIT { 0 }
+
+static char *parse_token(char **begin, const char *end)
+{
+       int size;
+       char *token, *pos = *begin;
+       while (pos != end && (*pos != ' ' && *pos != '\t' && *pos != '\n'))
+               pos++;
+       size = pos - *begin;
+       token = xstrndup(*begin, size);
+       *begin = pos + 1;
+       return token;
+}
+
+static char *get_next_line(char *const begin, const char *const end)
+{
+       char *pos = begin;
+       while (pos != end && *pos++ != '\n');
+       return pos;
+}
+
+static void show_fetch_remotes(FILE *output, const char *sm_name, const char *git_dir_path)
+{

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

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+       struct child_process cp_remote = CHILD_PROCESS_INIT;
+       struct strbuf sb_remote_out = STRBUF_INIT;
+
+       cp_remote.git_cmd = 1;
+       strvec_pushf(&cp_remote.env_array,
+                    "GIT_DIR=%s", git_dir_path);
+       strvec_push(&cp_remote.env_array, "GIT_WORK_TREE=.");
+       strvec_pushl(&cp_remote.args, "remote", "-v", NULL);
+       if (!capture_command(&cp_remote, &sb_remote_out, 0)) {
+               char *next_line, *name, *url, *tail;

Maybe name, url and tail could be declared in the while loop below where they are used.

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

Quoted 4 lines
builtin/submodule--helper.c +4 -0
+               char *begin = sb_remote_out.buf;
+               char *end = sb_remote_out.buf + sb_remote_out.len;
+               while (begin != end &&
+                      (next_line = get_next_line(begin, end))) {

It would be nice if the above 2 lines could be reduced into just one line. Maybe renaming "next_line" to just "line" could help with that.

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+                       name = parse_token(&begin, next_line);
+                       url = parse_token(&begin, next_line);
+                       tail = parse_token(&begin, next_line);
+                       if (!memcmp(tail, "(fetch)", 7))
+                               fprintf(output, "  %s\t%s\n", name, url);
+                       free(url);
+                       free(name);
+                       free(tail);
+               }
+       }

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

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+
+       strbuf_release(&sb_remote_out);
+}
+
+static int add_submodule(const struct add_data *info)
+{
+       char *submod_gitdir_path;
+       /* perhaps the path already exists and is already a git repo, else clone it */
+       if (is_directory(info->sm_path)) {
+               printf("sm_path=%s\n", info->sm_path);

Is this a leftover debug statement?

Quoted 40 lines
builtin/submodule--helper.c +40 -0
+               submod_gitdir_path = xstrfmt("%s/.git", info->sm_path);
+               if (is_directory(submod_gitdir_path) || file_exists(submod_gitdir_path))
+                       printf(_("Adding existing path at '%s' to index\n"),
+                              info->sm_path);
+               else
+                       die(_("'%s' already exists and is not a valid git repo"),
+                           info->sm_path);
+               free(submod_gitdir_path);
+       } else {
+               struct strvec clone_args = STRVEC_INIT;
+               struct child_process cp = CHILD_PROCESS_INIT;
+               submod_gitdir_path = xstrfmt(".git/modules/%s", info->sm_name);
+
+               if (is_directory(submod_gitdir_path)) {
+                       if (!info->force) {
+                               error(_("A git directory for '%s' is found "
+                                       "locally with remote(s):"), info->sm_name);
+                               show_fetch_remotes(stderr, info->sm_name,
+                                                  submod_gitdir_path);
+                               fprintf(stderr,
+                                       _("If you want to reuse this local git "
+                                         "directory instead of cloning again from\n"
+                                         "  %s\n"
+                                         "use the '--force' option. If the local git "
+                                         "directory is not the correct repo\n"
+                                         "or if you are unsure what this means, choose "
+                                         "another name with the '--name' option.\n"),
+                                       info->realrepo);
+                               free(submod_gitdir_path);
+                               return 1;
+                       } else {
+                               printf(_("Reactivating local git directory for "
+                                        "submodule '%s'\n"), info->sm_name);
+                       }
+               }
+               free(submod_gitdir_path);
+
+               strvec_push(&clone_args, "clone");
+
+               if (info->quiet)

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

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+                       strvec_push(&clone_args, "--quiet");
+
+               if (info->progress)
+                       strvec_push(&clone_args, "--progress");
+
+               if (info->prefix)
+                       strvec_pushl(&clone_args, "--prefix", info->prefix, NULL);
+
+               strvec_pushl(&clone_args, "--path", info->sm_path, "--name",
+                            info->sm_name, "--url", info->realrepo, NULL);

Maybe this unconditional strvec_pushl(...) could be squashed into the strvec_push(&clone_args, "clone") above.

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

Quoted 7 lines
builtin/submodule--helper.c +7 -0
+               if (info->reference_path)
+                       strvec_pushl(&clone_args, "--reference",
+                                    info->reference_path, NULL);
+
+               if (info->dissociate)
+                       strvec_push(&clone_args, "--dissociate");
+

Blank lines since the above strvec_push(&clone_args, "clone") could perhaps be removed.

Quoted 56 lines
builtin/submodule--helper.c +56 -0
+               if (info->depth >= 0)
+                       strvec_pushf(&clone_args, "--depth=%d", info->depth);
+
+               if (module_clone(clone_args.nr, clone_args.v, info->prefix)) {
+                       strvec_clear(&clone_args);
+                       return -1;
+               }
+               strvec_clear(&clone_args);
+
+               prepare_submodule_repo_env(&cp.env_array);
+               cp.git_cmd = 1;
+               cp.dir = info->sm_path;
+               strvec_pushl(&cp.args, "checkout", "-f", "-q", NULL);
+
+               if (info->branch) {
+                       strvec_pushl(&cp.args, "-B", info->branch, NULL);
+                       strvec_pushf(&cp.args, "origin/%s", info->branch);
+               }
+
+               if (run_command(&cp))
+                       die(_("unable to checkout submodule '%s'"), info->sm_path);
+       }
+       return 0;
+}
+
+static int add_clone(int argc, const char **argv, const char *prefix)
+{
+       const char *branch = NULL, *sm_path = NULL;
+       const char *wt_prefix = NULL, *realrepo = NULL;
+       const char *reference = NULL, *sm_name = NULL;
+       int force = 0, quiet = 0, dissociate = 0, depth = -1, progress = 0;
+       struct add_data info = ADD_DATA_INIT;
+
+       struct option options[] = {
+               OPT_STRING('b', "branch", &branch,
+                          N_("branch"),
+                          N_("branch of repository to checkout on cloning")),
+               OPT_STRING(0, "prefix", &wt_prefix,
+                          N_("path"),
+                          N_("alternative anchor for relative paths")),
+               OPT_STRING(0, "path", &sm_path,
+                          N_("path"),
+                          N_("where the new submodule will be cloned to")),
+               OPT_STRING(0, "name", &sm_name,
+                          N_("string"),
+                          N_("name of the new submodule")),
+               OPT_STRING(0, "url", &realrepo,
+                          N_("string"),
+                          N_("url where to clone the submodule from")),
+               OPT_STRING(0, "reference", &reference,
+                          N_("repo"),
+                          N_("reference repository")),
+               OPT_BOOL(0, "dissociate", &dissociate,
+                          N_("use --reference only while cloning")),
+               OPT_INTEGER(0, "depth", &depth,
+                           N_("depth for shallow clones")),

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

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+               OPT_BOOL(0, "progress", &progress,
+                          N_("force cloning progress")),
+               OPT_BOOL('f', "force", &force,
+                        N_("allow adding an otherwise ignored submodule path")),
+               OPT__QUIET(&quiet, "Suppress output for cloning a submodule"),
+               OPT_END()
+       };
+
+       const char *const usage[] = {
+               N_("git submodule--helper clone [--prefix=<path>] [--quiet] [--force] "

s/clone/add-clone/

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

Quoted 2 lines
builtin/submodule--helper.c +2 -0
+                  "[--reference <repository>] [--depth <depth>] [-b|--branch <branch>]"
+                  "--url <url> --path <path> --name <name>"),

The --progress and --dissociate options seem to be missing.

Quoted 2 lines
builtin/submodule--helper.c +2 -0
+               NULL
+       };
#2 lore raw
Quoted 18 lines · Christian Couder
Quoted 2 lines · Atharva Raykar

Convert the the shell code that performs the cloning of the repository that is

s/the the/the/

Quoted 1 line

to be added, and checks out to the appropriate branch.

Something a bit more explicit might make things easier to understand. For example:

"Let's add a new "add-clone" 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 clones the repository that is to be added, and checks out to the appropriate branch."

Quoted 3 lines

Then a simpler title could be:

"submodule--helper: introduce add-clone subcommand"

Great suggestions. I'll update my commit message.

Quoted 19 lines
Quoted 5 lines

This is meant to be a faithful conversion that leaves the behaviour of 'submodule add' unchanged. The only minor change is that if a submodule name has been supplied with a name that clashes with a local submodule, the message shown to the user ("A git directory for 'foo' is found locally...") is prepended with "error" for clarity.

Good.

Quoted 11 lines

---

This is part of a series of changes that will result in all of 'submodule add' being converted to C, which is a more familiar language for Git developers, and paves the way to improve performance and portability.

Quoted 8 lines
Quoted 5 lines

I have made this patch based on Shourya's patch[1]. I have decided to send the changes in smaller, more reviewable parts. The add-clone subcommand of submodule--helper is an intermediate change, while I work on translating all of the code. So in the next few patches, this helper subcommand is likely to be removed as its functionality would be invoked from the C code itself.

It might be a good idea to let us know how many such new subcommands you'd like to introduce before removing them.

I'll add that in my description of v2.

Quoted 4 lines

Anyway I think it's a good idea to send changes in smaller, more easily reviewable parts. Hopefully this way more work will end up being merged.

Quoted 16 lines

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

Quoted 13 lines

[...]

builtin/submodule--helper.c +12 -0
+static void show_fetch_remotes(FILE *output, const char *sm_name, const char *git_dir_path)
+{
+       struct child_process cp_remote = CHILD_PROCESS_INIT;
+       struct strbuf sb_remote_out = STRBUF_INIT;
+
+       cp_remote.git_cmd = 1;
+       strvec_pushf(&cp_remote.env_array,
+                    "GIT_DIR=%s", git_dir_path);
+       strvec_push(&cp_remote.env_array, "GIT_WORK_TREE=.");
+       strvec_pushl(&cp_remote.args, "remote", "-v", NULL);
+       if (!capture_command(&cp_remote, &sb_remote_out, 0)) {
+               char *next_line, *name, *url, *tail;

Maybe name, url and tail could be declared in the while loop below where they are used.

Will do. Just to better understand your intent, is the reason to do this to make the declarations closer to usage, for the sake of better readability?

I've not yet fully developed a taste for good C style, so I wanted to ask, which one looks better to you in these?

/* Sample 1 */

while (begin != end && (line = get_next_line(begin, end))) {
	char *name, *url, *tail;
	name = parse_token(&begin, next_line);
	url = parse_token(&begin, next_line);
	tail = parse_token(&begin, next_line);
	...
}

/* Sample 2 */

while (begin != end && (line = get_next_line(begin, end))) {
	char *name = parse_token(&begin, next_line);
	char *url = parse_token(&begin, next_line);
	char *tail = parse_token(&begin, next_line);
	...
}
Quoted 7 lines

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

Quoted 4 lines
builtin/submodule--helper.c +4 -0
+               char *begin = sb_remote_out.buf;
+               char *end = sb_remote_out.buf + sb_remote_out.len;
+               while (begin != end &&
+                      (next_line = get_next_line(begin, end))) {

It would be nice if the above 2 lines could be reduced into just one line. Maybe renaming "next_line" to just "line" could help with that.

Noted.

Quoted 14 lines
Quoted 14 lines
builtin/submodule--helper.c +14 -0
+                       name = parse_token(&begin, next_line);
+                       url = parse_token(&begin, next_line);
+                       tail = parse_token(&begin, next_line);
+                       if (!memcmp(tail, "(fetch)", 7))
+                               fprintf(output, "  %s\t%s\n", name, url);
+                       free(url);
+                       free(name);
+                       free(tail);
+               }
+       }
+
+       strbuf_release(&sb_remote_out);
+}
+
Quoted 8 lines

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

Quoted 6 lines
builtin/submodule--helper.c +6 -0
+static int add_submodule(const struct add_data *info)
+{
+       char *submod_gitdir_path;
+       /* perhaps the path already exists and is already a git repo, else clone it */
+       if (is_directory(info->sm_path)) {
+               printf("sm_path=%s\n", info->sm_path);

Is this a leftover debug statement?

Nope, at least not _my_ leftover debug statement.

I saw it in git-submodule.sh here, so I preserved it:

- # perhaps the path exists and is already a git repo, else clone it
- if test -e "$sm_path"
- ...

Personally, I found that comment quite useful when I was trying to understand the shell version, because at a glance I immediately knew what the intention of the big block of code was, that followed the comment.

Perhaps it could be broken into many functions to make it more readable without needing a comment, but that is outside the scope of this particular patch, which is aiming for a faithful conversion.

Quoted 45 lines
Quoted 45 lines
builtin/submodule--helper.c +45 -0
+               submod_gitdir_path = xstrfmt("%s/.git", info->sm_path);
+               if (is_directory(submod_gitdir_path) || file_exists(submod_gitdir_path))
+                       printf(_("Adding existing path at '%s' to index\n"),
+                              info->sm_path);
+               else
+                       die(_("'%s' already exists and is not a valid git repo"),
+                           info->sm_path);
+               free(submod_gitdir_path);
+       } else {
+               struct strvec clone_args = STRVEC_INIT;
+               struct child_process cp = CHILD_PROCESS_INIT;
+               submod_gitdir_path = xstrfmt(".git/modules/%s", info->sm_name);
+
+               if (is_directory(submod_gitdir_path)) {
+                       if (!info->force) {
+                               error(_("A git directory for '%s' is found "
+                                       "locally with remote(s):"), info->sm_name);
+                               show_fetch_remotes(stderr, info->sm_name,
+                                                  submod_gitdir_path);
+                               fprintf(stderr,
+                                       _("If you want to reuse this local git "
+                                         "directory instead of cloning again from\n"
+                                         "  %s\n"
+                                         "use the '--force' option. If the local git "
+                                         "directory is not the correct repo\n"
+                                         "or if you are unsure what this means, choose "
+                                         "another name with the '--name' option.\n"),
+                                       info->realrepo);
+                               free(submod_gitdir_path);
+                               return 1;
+                       } else {
+                               printf(_("Reactivating local git directory for "
+                                        "submodule '%s'\n"), info->sm_name);
+                       }
+               }
+               free(submod_gitdir_path);
+
+               strvec_push(&clone_args, "clone");
+
+               if (info->quiet)
+                       strvec_push(&clone_args, "--quiet");
+
+               if (info->progress)
+                       strvec_push(&clone_args, "--progress");
+
Quoted 8 lines

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

Quoted 5 lines
builtin/submodule--helper.c +5 -0
+               if (info->prefix)
+                       strvec_pushl(&clone_args, "--prefix", info->prefix, NULL);
+
+               strvec_pushl(&clone_args, "--path", info->sm_path, "--name",
+                            info->sm_name, "--url", info->realrepo, NULL);

Maybe this unconditional strvec_pushl(...) could be squashed into the strvec_push(&clone_args, "clone") above.

Got it.

Quoted 10 lines

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

Quoted 7 lines
builtin/submodule--helper.c +7 -0
+               if (info->reference_path)
+                       strvec_pushl(&clone_args, "--reference",
+                                    info->reference_path, NULL);
+
+               if (info->dissociate)
+                       strvec_push(&clone_args, "--dissociate");
+

Blank lines since the above strvec_push(&clone_args, "clone") could perhaps be removed.

Will do.

Quoted 10 lines

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

Quoted 3 lines

[...]

builtin/submodule--helper.c +2 -0
+       const char *const usage[] = {
+               N_("git submodule--helper clone [--prefix=<path>] [--quiet] [--force] "

s/clone/add-clone/

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

Quoted 2 lines
builtin/submodule--helper.c +2 -0
+                  "[--reference <repository>] [--depth <depth>] [-b|--branch <branch>]"
+                  "--url <url> --path <path> --name <name>"),

The --progress and --dissociate options seem to be missing.

Thanks, will fix.

Quoted 2 lines
Quoted 2 lines
builtin/submodule--helper.c +2 -0
+               NULL
+       };
#3 lore raw
Quoted 17 lines · Atharva Raykar

[...]
I've not yet fully developed a taste for good C style, so I wanted to ask, which one looks better to you in these?

/* Sample 1 */

while (begin != end && (line = get_next_line(begin, end))) {
	char *name, *url, *tail;
	name = parse_token(&begin, next_line);
	url = parse_token(&begin, next_line);
	tail = parse_token(&begin, next_line);
	...
}
Quoted 7 lines

/* Sample 2 */

while (begin != end && (line = get_next_line(begin, end))) {
	char *name = parse_token(&begin, next_line);
	char *url = parse_token(&begin, next_line);
	char *tail = parse_token(&begin, next_line);
	...
}

Also ignore the error here, assume: s/next_line/line/ (Anyway, my question was about style)

#4 lore raw

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

In reply to Atharva Raykar

Let's add a new "add-clone" 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 clones the repository that is to be added, and checks out to the appropriate branch.

This is meant to be a faithful conversion that leaves the behaviour of 'submodule add' unchanged. The only minor change is that if a submodule name has been supplied with a name that clashes with a local submodule, the message shown to the user ("A git directory for 'foo' is found locally...") is prepended with "error" for clarity.

This is part of a series of changes that will result in all of 'submodule add' being converted to C.

---

This is part of a series of changes that will result in all of 'submodule add' being converted to C, which is a more familiar language for Git developers, and paves the way to improve performance and portability.

I have made this patch based on Shourya's patch[1]. I have decided to send the changes in smaller, more reviewable parts. The add-clone subcommand of submodule--helper is an intermediate change, while I work on translating all of the code.

Another subcommand called 'add-config' will also be added in a separate patch that handles the configuration on adding the module.

After those two changes look good enough, I will be converting whatever is left of 'git submodule add' in the git-submodule.sh past the flag parsing into C code by having one helper subcommand called 'git submodule--helper add' that will incorporate the functionality of the other two helpers, as well. In that patch, the 'add-clone' and 'add-config' subcommands will be removed from the commands array, as they will be called from within the C code itself.

Changes since v1:
* Fixed typos, and made commit message more explicit
* Fixed incorrect usage string
* Some style changes were made

 builtin/submodule--helper.c | 212 ++++++++++++++++++++++++++++++++++++
 git-submodule.sh            |  38 +------
 2 files changed, 213 insertions(+), 37 deletions(-)
builtin/submodule--helper.c +212 -0
index d55f6262e9..bbbb42088b 100644
@@ -2745,6 +2745,217 @@ static int module_set_branch(int argc, const char **argv, const char *prefix)
 	return !!ret;
 }
 
+struct add_data {
+	const char *prefix;
+	const char *branch;
+	const char *reference_path;
+	const char *sm_path;
+	const char *sm_name;
+	const char *repo;
+	const char *realrepo;
+	int depth;
+	unsigned int force: 1;
+	unsigned int quiet: 1;
+	unsigned int progress: 1;
+	unsigned int dissociate: 1;
+};
+#define ADD_DATA_INIT { 0 }
+
+static char *parse_token(char **begin, const char *end)
+{
+	int size;
+	char *token, *pos = *begin;
+	while (pos != end && (*pos != ' ' && *pos != '\t' && *pos != '\n'))
+		pos++;
+	size = pos - *begin;
+	token = xstrndup(*begin, size);
+	*begin = pos + 1;
+	return token;
+}
+
+static char *get_next_line(char *const begin, const char *const end)
+{
+	char *pos = begin;
+	while (pos != end && *pos++ != '\n');
+	return pos;
+}
+
+static void show_fetch_remotes(FILE *output, const char *sm_name, const char *git_dir_path)
+{
+	struct child_process cp_remote = CHILD_PROCESS_INIT;
+	struct strbuf sb_remote_out = STRBUF_INIT;
+
+	cp_remote.git_cmd = 1;
+	strvec_pushf(&cp_remote.env_array,
+		     "GIT_DIR=%s", git_dir_path);
+	strvec_push(&cp_remote.env_array, "GIT_WORK_TREE=.");
+	strvec_pushl(&cp_remote.args, "remote", "-v", NULL);
+	if (!capture_command(&cp_remote, &sb_remote_out, 0)) {
+		char *line;
+		char *begin = sb_remote_out.buf;
+		char *end = sb_remote_out.buf + sb_remote_out.len;
+		while (begin != end && (line = get_next_line(begin, end))) {
+			char *name, *url, *tail;
+			name = parse_token(&begin, line);
+			url = parse_token(&begin, line);
+			tail = parse_token(&begin, line);
+			if (!memcmp(tail, "(fetch)", 7))
+				fprintf(output, "  %s\t%s\n", name, url);
+			free(url);
+			free(name);
+			free(tail);
+		}
+	}
+
+	strbuf_release(&sb_remote_out);
+}
+
+static int add_submodule(const struct add_data *info)
+{
+	char *submod_gitdir_path;
+	/* perhaps the path already exists and is already a git repo, else clone it */
+	if (is_directory(info->sm_path)) {
+		printf("sm_path=%s\n", info->sm_path);
+		submod_gitdir_path = xstrfmt("%s/.git", info->sm_path);
+		if (is_directory(submod_gitdir_path) || file_exists(submod_gitdir_path))
+			printf(_("Adding existing path at '%s' to index\n"),
+			       info->sm_path);
+		else
+			die(_("'%s' already exists and is not a valid git repo"),
+			    info->sm_path);
+		free(submod_gitdir_path);
+	} else {
+		struct strvec clone_args = STRVEC_INIT;
+		struct child_process cp = CHILD_PROCESS_INIT;
+		submod_gitdir_path = xstrfmt(".git/modules/%s", info->sm_name);
+
+		if (is_directory(submod_gitdir_path)) {
+			if (!info->force) {
+				error(_("A git directory for '%s' is found "
+					"locally with remote(s):"), info->sm_name);
+				show_fetch_remotes(stderr, info->sm_name,
+						   submod_gitdir_path);
+				fprintf(stderr,
+					_("If you want to reuse this local git "
+					  "directory instead of cloning again from\n"
+					  "  %s\n"
+					  "use the '--force' option. If the local git "
+					  "directory is not the correct repo\n"
+					  "or if you are unsure what this means, choose "
+					  "another name with the '--name' option.\n"),
+					info->realrepo);
+				free(submod_gitdir_path);
+				return 1;
+			} else {
+				printf(_("Reactivating local git directory for "
+					 "submodule '%s'\n"), info->sm_name);
+			}
+		}
+		free(submod_gitdir_path);
+
+		strvec_pushl(&clone_args, "clone", "--path", info->sm_path, "--name",
+			     info->sm_name, "--url", info->realrepo, NULL);
+		if (info->quiet)
+			strvec_push(&clone_args, "--quiet");
+		if (info->progress)
+			strvec_push(&clone_args, "--progress");
+		if (info->prefix)
+			strvec_pushl(&clone_args, "--prefix", info->prefix, NULL);
+		if (info->reference_path)
+			strvec_pushl(&clone_args, "--reference",
+				     info->reference_path, NULL);
+		if (info->dissociate)
+			strvec_push(&clone_args, "--dissociate");
+		if (info->depth >= 0)
+			strvec_pushf(&clone_args, "--depth=%d", info->depth);
+		if (module_clone(clone_args.nr, clone_args.v, info->prefix)) {
+			strvec_clear(&clone_args);
+			return -1;
+		}
+		strvec_clear(&clone_args);
+
+		prepare_submodule_repo_env(&cp.env_array);
+		cp.git_cmd = 1;
+		cp.dir = info->sm_path;
+		strvec_pushl(&cp.args, "checkout", "-f", "-q", NULL);
+
+		if (info->branch) {
+			strvec_pushl(&cp.args, "-B", info->branch, NULL);
+			strvec_pushf(&cp.args, "origin/%s", info->branch);
+		}
+
+		if (run_command(&cp))
+			die(_("unable to checkout submodule '%s'"), info->sm_path);
+	}
+	return 0;
+}
+
+static int add_clone(int argc, const char **argv, const char *prefix)
+{
+	const char *branch = NULL, *sm_path = NULL;
+	const char *wt_prefix = NULL, *realrepo = NULL;
+	const char *reference = NULL, *sm_name = NULL;
+	int force = 0, quiet = 0, dissociate = 0, depth = -1, progress = 0;
+	struct add_data info = ADD_DATA_INIT;
+
+	struct option options[] = {
+		OPT_STRING('b', "branch", &branch,
+			   N_("branch"),
+			   N_("branch of repository to checkout on cloning")),
+		OPT_STRING(0, "prefix", &wt_prefix,
+			   N_("path"),
+			   N_("alternative anchor for relative paths")),
+		OPT_STRING(0, "path", &sm_path,
+			   N_("path"),
+			   N_("where the new submodule will be cloned to")),
+		OPT_STRING(0, "name", &sm_name,
+			   N_("string"),
+			   N_("name of the new submodule")),
+		OPT_STRING(0, "url", &realrepo,
+			   N_("string"),
+			   N_("url where to clone the submodule from")),
+		OPT_STRING(0, "reference", &reference,
+			   N_("repo"),
+			   N_("reference repository")),
+		OPT_BOOL(0, "dissociate", &dissociate,
+			   N_("use --reference only while cloning")),
+		OPT_INTEGER(0, "depth", &depth,
+			    N_("depth for shallow clones")),
+		OPT_BOOL(0, "progress", &progress,
+			   N_("force cloning progress")),
+		OPT_BOOL('f', "force", &force,
+			 N_("allow adding an otherwise ignored submodule path")),
+		OPT__QUIET(&quiet, "Suppress output for cloning a submodule"),
+		OPT_END()
+	};
+
+	const char *const usage[] = {
+		N_("git submodule--helper add-clone [--prefix=<path>] [--quiet] [--force] "
+		   "[--reference <repository>] [--depth <depth>] [-b|--branch <branch>]"
+		   "[--progress] [--dissociate] --url <url> --path <path> --name <name>"),
+		NULL
+	};
+
+	argc = parse_options(argc, argv, prefix, options, usage, 0);
+
+	info.prefix = prefix;
+	info.sm_name = sm_name;
+	info.sm_path = sm_path;
+	info.realrepo = realrepo;
+	info.reference_path = reference;
+	info.branch = branch;
+	info.depth = depth;
+	info.progress = !!progress;
+	info.dissociate = !!dissociate;
+	info.force = !!force;
+	info.quiet = !!quiet;
+
+	if (add_submodule(&info))
+		return 1;
+
+	return 0;
+}
+
 #define SUPPORT_SUPER_PREFIX (1<<0)
 
 struct cmd_struct {
@@ -2757,6 +2968,7 @@ static struct cmd_struct commands[] = {
 	{"list", module_list, 0},
 	{"name", module_name, 0},
 	{"clone", module_clone, 0},
+	{"add-clone", add_clone, 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 -37
index 4678378424..f71e1e5495 100755
@@ -241,43 +241,7 @@ cmd_add()
 		die "$(eval_gettext "'$sm_name' is not a valid submodule name")"
 	fi
 
-	# perhaps the path exists and is already a git repo, else clone it
-	if test -e "$sm_path"
-	then
-		if test -d "$sm_path"/.git || test -f "$sm_path"/.git
-		then
-			eval_gettextln "Adding existing repo at '\$sm_path' to the index"
-		else
-			die "$(eval_gettext "'\$sm_path' already exists and is not a valid git repo")"
-		fi
-
-	else
-		if test -d ".git/modules/$sm_name"
-		then
-			if test -z "$force"
-			then
-				eval_gettextln >&2 "A git directory for '\$sm_name' is found locally with remote(s):"
-				GIT_DIR=".git/modules/$sm_name" GIT_WORK_TREE=. git remote -v | grep '(fetch)' | sed -e s,^,"  ", -e s,' (fetch)',, >&2
-				die "$(eval_gettextln "\
-If you want to reuse this local git directory instead of cloning again from
-  \$realrepo
-use the '--force' option. If the local git directory is not the correct repo
-or you are unsure what this means choose another name with the '--name' option.")"
-			else
-				eval_gettextln "Reactivating local git directory for submodule '\$sm_name'."
-			fi
-		fi
-		git submodule--helper clone ${GIT_QUIET:+--quiet} ${progress:+"--progress"} --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" ${reference:+"$reference"} ${dissociate:+"--dissociate"} ${depth:+"$depth"} || exit
-		(
-			sanitize_submodule_env
-			cd "$sm_path" &&
-			# ash fails to wordsplit ${branch:+-b "$branch"...}
-			case "$branch" in
-			'') git checkout -f -q ;;
-			?*) git checkout -f -q -B "$branch" "origin/$branch" ;;
-			esac
-		) || die "$(eval_gettext "Unable to checkout submodule '\$sm_path'")"
-	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" ||
Signature · 1 line
2.31.1
#5 lore raw

Re: [PATCH v2] [GSoC] submodule--helper: introduce add-clone subcommand

Quoted 9 lines · Atharva Raykar
builtin/submodule--helper.c +9 -0
+static void show_fetch_remotes(FILE *output, const char *sm_name, const char *git_dir_path)
+{
+       struct child_process cp_remote = CHILD_PROCESS_INIT;
+       struct strbuf sb_remote_out = STRBUF_INIT;
+
+       cp_remote.git_cmd = 1;
+       strvec_pushf(&cp_remote.env_array,
+                    "GIT_DIR=%s", git_dir_path);
+       strvec_push(&cp_remote.env_array, "GIT_WORK_TREE=.");

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

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+       strvec_pushl(&cp_remote.args, "remote", "-v", NULL);
+       if (!capture_command(&cp_remote, &sb_remote_out, 0)) {
+               char *line;
+               char *begin = sb_remote_out.buf;
+               char *end = sb_remote_out.buf + sb_remote_out.len;
+               while (begin != end && (line = get_next_line(begin, end))) {
+                       char *name, *url, *tail;
+                       name = parse_token(&begin, line);
+                       url = parse_token(&begin, line);
+                       tail = parse_token(&begin, line);

Sorry for not replying to your earlier message, but I think it's a bit better to save a line with:

                       char *name = parse_token(&begin, line);
                       char *url = parse_token(&begin, line);
                       char *tail = parse_token(&begin, line);
Quoted 7 lines
builtin/submodule--helper.c +7 -0
+                       if (!memcmp(tail, "(fetch)", 7))
+                               fprintf(output, "  %s\t%s\n", name, url);
+                       free(url);
+                       free(name);
+                       free(tail);
+               }
+       }

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

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+
+       strbuf_release(&sb_remote_out);
+}
+
+static int add_submodule(const struct add_data *info)
+{
+       char *submod_gitdir_path;
+       /* perhaps the path already exists and is already a git repo, else clone it */
+       if (is_directory(info->sm_path)) {
+               printf("sm_path=%s\n", info->sm_path);

I don't see which shell code the above printf(...) instruction is replacing. That's why I asked if it's some debugging leftover.

[...]

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

Quoted 4 lines
builtin/submodule--helper.c +4 -0
+               if (info->dissociate)
+                       strvec_push(&clone_args, "--dissociate");
+               if (info->depth >= 0)
+                       strvec_pushf(&clone_args, "--depth=%d", info->depth);

It's ok if there is a blank line here.

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

Quoted 13 lines
builtin/submodule--helper.c +12 -0
+               if (module_clone(clone_args.nr, clone_args.v, info->prefix)) {
+                       strvec_clear(&clone_args);
+                       return -1;
+               }
+               strvec_clear(&clone_args);
 
+static int add_clone(int argc, const char **argv, const char *prefix)
+{
+       const char *branch = NULL, *sm_path = NULL;
+       const char *wt_prefix = NULL, *realrepo = NULL;
+       const char *reference = NULL, *sm_name = NULL;
+       int force = 0, quiet = 0, dissociate = 0, depth = -1, progress = 0;
+       struct add_data info = ADD_DATA_INIT;

Maybe: s/info/add_data/

Also it seems that in many cases it's a bit wasteful to use new variables for option parsing and then to copy them into the add_data struct when the field of the add_data struct could be used directly for option parsing...

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

Quoted 2 lines
builtin/submodule--helper.c +2 -0
+       struct option options[] = {
+               OPT_STRING('b', "branch", &branch,

...for example, here maybe &add_data.branch could be used instead of &branch...

Quoted 2 lines
builtin/submodule--helper.c +2 -0
+                          N_("branch"),
+                          N_("branch of repository to checkout on cloning")),

[...]

Quoted 1 line

+ info.branch = branch;

...so that the above line would not be needed.

#6 lore raw

Re: [PATCH v2] [GSoC] submodule--helper: introduce add-clone subcommand

Quoted 26 lines · Christian Couder
Quoted 9 lines · Atharva Raykar
builtin/submodule--helper.c +9 -0
+static void show_fetch_remotes(FILE *output, const char *sm_name, const char *git_dir_path)
+{
+       struct child_process cp_remote = CHILD_PROCESS_INIT;
+       struct strbuf sb_remote_out = STRBUF_INIT;
+
+       cp_remote.git_cmd = 1;
+       strvec_pushf(&cp_remote.env_array,
+                    "GIT_DIR=%s", git_dir_path);
+       strvec_push(&cp_remote.env_array, "GIT_WORK_TREE=.");

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

Quoted 10 lines
builtin/submodule--helper.c +10 -0
+       strvec_pushl(&cp_remote.args, "remote", "-v", NULL);
+       if (!capture_command(&cp_remote, &sb_remote_out, 0)) {
+               char *line;
+               char *begin = sb_remote_out.buf;
+               char *end = sb_remote_out.buf + sb_remote_out.len;
+               while (begin != end && (line = get_next_line(begin, end))) {
+                       char *name, *url, *tail;
+                       name = parse_token(&begin, line);
+                       url = parse_token(&begin, line);
+                       tail = parse_token(&begin, line);

Sorry for not replying to your earlier message, but I think it's a bit better to save a line with:

Quoted 3 lines
                      char *name = parse_token(&begin, line);
                      char *url = parse_token(&begin, line);
                      char *tail = parse_token(&begin, line);

Alright.

Quoted 12 lines
Quoted 12 lines
builtin/submodule--helper.c +12 -0
+                       if (!memcmp(tail, "(fetch)", 7))
+                               fprintf(output, "  %s\t%s\n", name, url);
+                       free(url);
+                       free(name);
+                       free(tail);
+               }
+       }
+
+       strbuf_release(&sb_remote_out);
+}
+
+static int add_submodule(const struct add_data *info)
Quoted 8 lines

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

Quoted 5 lines
builtin/submodule--helper.c +5 -0
+{
+       char *submod_gitdir_path;
+       /* perhaps the path already exists and is already a git repo, else clone it */
+       if (is_directory(info->sm_path)) {
+               printf("sm_path=%s\n", info->sm_path);

I don't see which shell code the above printf(...) instruction is replacing. That's why I asked if it's some debugging leftover.

Oh, my bad. It is a leftover debugging statement. Please excuse my temporary blindness to it (:

Quoted 8 lines

[...]

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

Quoted 4 lines
builtin/submodule--helper.c +4 -0
+               if (info->dissociate)
+                       strvec_push(&clone_args, "--dissociate");
+               if (info->depth >= 0)
+                       strvec_pushf(&clone_args, "--depth=%d", info->depth);

It's ok if there is a blank line here.

OK. Makes sense.

Quoted 6 lines
Quoted 5 lines
builtin/submodule--helper.c +5 -0
+               if (module_clone(clone_args.nr, clone_args.v, info->prefix)) {
+                       strvec_clear(&clone_args);
+                       return -1;
+               }
+               strvec_clear(&clone_args);
Quoted 9 lines

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

Quoted 7 lines
builtin/submodule--helper.c +7 -0
+static int add_clone(int argc, const char **argv, const char *prefix)
+{
+       const char *branch = NULL, *sm_path = NULL;
+       const char *wt_prefix = NULL, *realrepo = NULL;
+       const char *reference = NULL, *sm_name = NULL;
+       int force = 0, quiet = 0, dissociate = 0, depth = -1, progress = 0;
+       struct add_data info = ADD_DATA_INIT;

Maybe: s/info/add_data/

'info' was the local convention for naming similar structures that held the flag values (like summary_cb, module_cb, deinit_cb etc).

The exception to the above is 'struct submodule_update_clone', which was named as 'suc'. It did not follow the *_cb naming convention, presumably because it was not used as a parameter passed to any *_cb() function.

Since 'struct add_data' is more similar to the latter (as it is not used in any callback function) I guess it would be okay to name it differently and more descriptively as 'add_data'?

Quoted 10 lines

Also it seems that in many cases it's a bit wasteful to use new variables for option parsing and then to copy them into the add_data struct when the field of the add_data struct could be used directly for option parsing...

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

Quoted 2 lines
builtin/submodule--helper.c +2 -0
+       struct option options[] = {
+               OPT_STRING('b', "branch", &branch,

...for example, here maybe &add_data.branch could be used instead of &branch...

I thought of this too, but decided to stick to the surrounding convention, where a new variable is used and then assigned to the struct.

I had a looked at the file again, and turns out...

OPT_STRING_LIST(0, "reference", &suc.references, N_("repo"),
N_("reference repository")),
OPT_BOOL(0, "dissociate", &suc.dissociate,
N_("use --reference only while cloning")),
OPT_STRING(0, "depth", &suc.depth, "<depth>",
N_("create a shallow clone truncated to the "
"specified number of revisions")),

... update_clone() is the exception again.

So there is precedent, and I'd rather follow what you suggested, because that looks much better to me, and saves a lot of redundant code.

Quoted 8 lines
Quoted 2 lines
builtin/submodule--helper.c +2 -0
+                          N_("branch"),
+                          N_("branch of repository to checkout on cloning")),

[...]

Quoted 1 line

+ info.branch = branch;

...so that the above line would not be needed.

Yes, although I might still need to use an extra variable for booleans, like 'progress' or 'dissociate', because of the need to use !! to make it either 1 or 0. I am not too familiar with why doing that would be important in this context, but since this is the convention, I'll keep it intact.

#7 lore raw

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

Let's add a new "add-clone" 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 clones the repository that is to be added, and checks out to the appropriate branch.

This is meant to be a faithful conversion that leaves the behaviour of 'submodule add' unchanged. The only minor change is that if a submodule name has been supplied with a name that clashes with a local submodule, the message shown to the user ("A git directory for 'foo' is found locally...") is prepended with "error" for clarity.

This is part of a series of changes that will result in all of 'submodule add' being converted to C.

---

Changes since v2:
* Remove printf debug statement that was accidentally inserted into the final patch
* Rename 'struct add_data info' to the more descriptive
'struct add_data add_data'
* Remove unnecessary variables while parsing flags, and insert into the struct members directly
* Eliminate extra heap allocation via 'xstrndup()' in parse_token() (I learnt this trick from Junio's comment on Shourya's v2 review of a similar patch :^) )

 builtin/submodule--helper.c | 199 ++++++++++++++++++++++++++++++++++++
 git-submodule.sh            |  38 +------
 2 files changed, 200 insertions(+), 37 deletions(-)
builtin/submodule--helper.c +199 -0
index d55f6262e9..c9cb535312 100644
@@ -2745,6 +2745,204 @@ static int module_set_branch(int argc, const char **argv, const char *prefix)
 	return !!ret;
 }
 
+struct add_data {
+	const char *prefix;
+	const char *branch;
+	const char *reference_path;
+	const char *sm_path;
+	const char *sm_name;
+	const char *repo;
+	const char *realrepo;
+	int depth;
+	unsigned int force: 1;
+	unsigned int quiet: 1;
+	unsigned int progress: 1;
+	unsigned int dissociate: 1;
+};
+#define ADD_DATA_INIT { .depth = -1 }
+
+static char *parse_token(char **begin, const char *end, int *tok_len)
+{
+	char *tok_start, *pos = *begin;
+	while (pos != end && (*pos != ' ' && *pos != '\t' && *pos != '\n'))
+		pos++;
+	tok_start = *begin;
+	*tok_len = pos - *begin;
+	*begin = pos + 1;
+	return tok_start;
+}
+
+static char *get_next_line(char *const begin, const char *const end)
+{
+	char *pos = begin;
+	while (pos != end && *pos++ != '\n');
+	return pos;
+}
+
+static void show_fetch_remotes(FILE *output, const char *sm_name, const char *git_dir_path)
+{
+	struct child_process cp_remote = CHILD_PROCESS_INIT;
+	struct strbuf sb_remote_out = STRBUF_INIT;
+
+	cp_remote.git_cmd = 1;
+	strvec_pushf(&cp_remote.env_array,
+		     "GIT_DIR=%s", git_dir_path);
+	strvec_push(&cp_remote.env_array, "GIT_WORK_TREE=.");
+	strvec_pushl(&cp_remote.args, "remote", "-v", NULL);
+	if (!capture_command(&cp_remote, &sb_remote_out, 0)) {
+		char *line;
+		char *begin = sb_remote_out.buf;
+		char *end = sb_remote_out.buf + sb_remote_out.len;
+		while (begin != end && (line = get_next_line(begin, end))) {
+			int namelen = 0, urllen = 0, taillen = 0;
+			char *name = parse_token(&begin, line, &namelen);
+			char *url = parse_token(&begin, line, &urllen);
+			char *tail = parse_token(&begin, line, &taillen);
+			if (!memcmp(tail, "(fetch)", 7))
+				fprintf(output, "  %.*s\t%.*s\n",
+					namelen, name, urllen, url);
+		}
+	}
+
+	strbuf_release(&sb_remote_out);
+}
+
+static int add_submodule(const struct add_data *add_data)
+{
+	char *submod_gitdir_path;
+	/* perhaps the path already exists and is already a git repo, else clone it */
+	if (is_directory(add_data->sm_path)) {
+		submod_gitdir_path = xstrfmt("%s/.git", add_data->sm_path);
+		if (is_directory(submod_gitdir_path) || file_exists(submod_gitdir_path))
+			printf(_("Adding existing path at '%s' to index\n"),
+			       add_data->sm_path);
+		else
+			die(_("'%s' already exists and is not a valid git repo"),
+			    add_data->sm_path);
+		free(submod_gitdir_path);
+	} else {
+		struct strvec clone_args = STRVEC_INIT;
+		struct child_process cp = CHILD_PROCESS_INIT;
+		submod_gitdir_path = xstrfmt(".git/modules/%s", add_data->sm_name);
+
+		if (is_directory(submod_gitdir_path)) {
+			if (!add_data->force) {
+				error(_("A git directory for '%s' is found "
+					"locally with remote(s):"), add_data->sm_name);
+				show_fetch_remotes(stderr, add_data->sm_name,
+						   submod_gitdir_path);
+				fprintf(stderr,
+					_("If you want to reuse this local git "
+					  "directory instead of cloning again from\n"
+					  "  %s\n"
+					  "use the '--force' option. If the local git "
+					  "directory is not the correct repo\n"
+					  "or if you are unsure what this means, choose "
+					  "another name with the '--name' option.\n"),
+					add_data->realrepo);
+				free(submod_gitdir_path);
+				return 1;
+			} else {
+				printf(_("Reactivating local git directory for "
+					 "submodule '%s'\n"), add_data->sm_name);
+			}
+		}
+		free(submod_gitdir_path);
+
+		strvec_pushl(&clone_args, "clone", "--path", add_data->sm_path, "--name",
+			     add_data->sm_name, "--url", add_data->realrepo, NULL);
+		if (add_data->quiet)
+			strvec_push(&clone_args, "--quiet");
+		if (add_data->progress)
+			strvec_push(&clone_args, "--progress");
+		if (add_data->prefix)
+			strvec_pushl(&clone_args, "--prefix", add_data->prefix, NULL);
+		if (add_data->reference_path)
+			strvec_pushl(&clone_args, "--reference",
+				     add_data->reference_path, NULL);
+		if (add_data->dissociate)
+			strvec_push(&clone_args, "--dissociate");
+		if (add_data->depth >= 0)
+			strvec_pushf(&clone_args, "--depth=%d", add_data->depth);
+
+		if (module_clone(clone_args.nr, clone_args.v, add_data->prefix)) {
+			strvec_clear(&clone_args);
+			return -1;
+		}
+		strvec_clear(&clone_args);
+
+		prepare_submodule_repo_env(&cp.env_array);
+		cp.git_cmd = 1;
+		cp.dir = add_data->sm_path;
+		strvec_pushl(&cp.args, "checkout", "-f", "-q", NULL);
+
+		if (add_data->branch) {
+			strvec_pushl(&cp.args, "-B", add_data->branch, NULL);
+			strvec_pushf(&cp.args, "origin/%s", add_data->branch);
+		}
+
+		if (run_command(&cp))
+			die(_("unable to checkout submodule '%s'"), add_data->sm_path);
+	}
+	return 0;
+}
+
+static int add_clone(int argc, const char **argv, const char *prefix)
+{
+	int force = 0, quiet = 0, dissociate = 0, progress = 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 checkout on cloning")),
+		OPT_STRING(0, "prefix", &add_data.prefix,
+			   N_("path"),
+			   N_("alternative anchor for relative paths")),
+		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_STRING(0, "url", &add_data.realrepo,
+			   N_("string"),
+			   N_("url where to clone the submodule from")),
+		OPT_STRING(0, "reference", &add_data.reference_path,
+			   N_("repo"),
+			   N_("reference repository")),
+		OPT_BOOL(0, "dissociate", &dissociate,
+			 N_("use --reference only while cloning")),
+		OPT_INTEGER(0, "depth", &add_data.depth,
+			    N_("depth for shallow clones")),
+		OPT_BOOL(0, "progress", &progress,
+			 N_("force cloning progress")),
+		OPT_BOOL('f', "force", &force,
+			 N_("allow adding an otherwise ignored submodule path")),
+		OPT__QUIET(&quiet, "Suppress output for cloning a submodule"),
+		OPT_END()
+	};
+
+	const char *const usage[] = {
+		N_("git submodule--helper add-clone [--prefix=<path>] [--quiet] [--force] "
+		   "[--reference <repository>] [--depth <depth>] [-b|--branch <branch>]"
+		   "[--progress] [--dissociate] --url <url> --path <path> --name <name>"),
+		NULL
+	};
+
+	argc = parse_options(argc, argv, prefix, options, usage, 0);
+
+	add_data.progress = !!progress;
+	add_data.dissociate = !!dissociate;
+	add_data.force = !!force;
+	add_data.quiet = !!quiet;
+
+	if (add_submodule(&add_data))
+		return 1;
+
+	return 0;
+}
+
 #define SUPPORT_SUPER_PREFIX (1<<0)
 
 struct cmd_struct {
@@ -2757,6 +2955,7 @@ static struct cmd_struct commands[] = {
 	{"list", module_list, 0},
 	{"name", module_name, 0},
 	{"clone", module_clone, 0},
+	{"add-clone", add_clone, 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 -37
index 4678378424..f71e1e5495 100755
@@ -241,43 +241,7 @@ cmd_add()
 		die "$(eval_gettext "'$sm_name' is not a valid submodule name")"
 	fi
 
-	# perhaps the path exists and is already a git repo, else clone it
-	if test -e "$sm_path"
-	then
-		if test -d "$sm_path"/.git || test -f "$sm_path"/.git
-		then
-			eval_gettextln "Adding existing repo at '\$sm_path' to the index"
-		else
-			die "$(eval_gettext "'\$sm_path' already exists and is not a valid git repo")"
-		fi
-
-	else
-		if test -d ".git/modules/$sm_name"
-		then
-			if test -z "$force"
-			then
-				eval_gettextln >&2 "A git directory for '\$sm_name' is found locally with remote(s):"
-				GIT_DIR=".git/modules/$sm_name" GIT_WORK_TREE=. git remote -v | grep '(fetch)' | sed -e s,^,"  ", -e s,' (fetch)',, >&2
-				die "$(eval_gettextln "\
-If you want to reuse this local git directory instead of cloning again from
-  \$realrepo
-use the '--force' option. If the local git directory is not the correct repo
-or you are unsure what this means choose another name with the '--name' option.")"
-			else
-				eval_gettextln "Reactivating local git directory for submodule '\$sm_name'."
-			fi
-		fi
-		git submodule--helper clone ${GIT_QUIET:+--quiet} ${progress:+"--progress"} --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" ${reference:+"$reference"} ${dissociate:+"--dissociate"} ${depth:+"$depth"} || exit
-		(
-			sanitize_submodule_env
-			cd "$sm_path" &&
-			# ash fails to wordsplit ${branch:+-b "$branch"...}
-			case "$branch" in
-			'') git checkout -f -q ;;
-			?*) git checkout -f -q -B "$branch" "origin/$branch" ;;
-			esac
-		) || die "$(eval_gettext "Unable to checkout submodule '\$sm_path'")"
-	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" ||
Signature · 1 line
2.31.1
#8 lore raw

Re: [PATCH v3] [GSoC] submodule--helper: introduce add-clone subcommand

Quoted 23 lines · Atharva Raykar

Let's add a new "add-clone" 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 clones the repository that is to be added, and checks out to the appropriate branch.

This is meant to be a faithful conversion that leaves the behaviour of 'submodule add' unchanged. The only minor change is that if a submodule name has been supplied with a name that clashes with a local submodule, the message shown to the user ("A git directory for 'foo' is found locally...") is prepended with "error" for clarity.

This is part of a series of changes that will result in all of 'submodule add' being converted to C.

---

Quoted 10 lines

Changes since v2:
* Remove printf debug statement that was accidentally inserted into the final patch
* Rename 'struct add_data info' to the more descriptive
'struct add_data add_data'
* Remove unnecessary variables while parsing flags, and insert into the struct members directly
* Eliminate extra heap allocation via 'xstrndup()' in parse_token() (I learnt this trick from Junio's comment on Shourya's v2 review of a similar patch :^) )

I forgot to mention, but this patch can be fetched via GitHub from:

https://github.com/tfidfwastaken/git/tree/submodule-add-in-c-add-clone-v3

#9 lore raw

Re: [PATCH v2] [GSoC] submodule--helper: introduce add-clone subcommand

In reply to Atharva Raykar

Hi Atharva!

Quoted 7 lines · Atharva Raykar

Let's add a new "add-clone" 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 clones the repository that is to be added, and checks out to the appropriate branch.

Quoted 5 lines

This is meant to be a faithful conversion that leaves the behaviour of 'submodule add' unchanged. The only minor change is that if a submodule name has been supplied with a name that clashes with a local submodule, the message shown to the user ("A git directory for 'foo' is found locally...") is prepended with "error" for clarity.

It would be better if commit messages are limited to 72 columns (characters) per line.
Though you can obviously write longer lines on the list no problem.

Quoted 8 lines

This is part of a series of changes that will result in all of 'submodule add' being converted to C.

I and others before me used to sign off the previous authors using 'Signed-off-by:'. This trailer
has not been used yet so I am not sure if it should be used though I prefer this over the former.
Maybe Christian could comment here?

Quoted 12 lines

This is part of a series of changes that will result in all of 'submodule add' being converted to C, which is a more familiar language for Git developers, and paves the way to improve performance and portability.

I have made this patch based on Shourya's patch[1]. I have decided to send the changes in smaller, more reviewable parts. The add-clone subcommand of submodule--helper is an intermediate change, while I work on translating all of the code.

Another subcommand called 'add-config' will also be added in a separate patch that handles the configuration on adding the module.

Quoted 6 lines

After those two changes look good enough, I will be converting whatever is left of 'git submodule add' in the git-submodule.sh past the flag parsing into C code by having one helper subcommand called 'git submodule--helper add' that will incorporate the functionality of the other two helpers, as well. In that patch, the 'add-clone' and 'add-config' subcommands will be removed from the commands array, as they will be called from within the C code itself.

Seems like a good approach! BTW, if this "extra" message is a bit long like the one above, then
you can put it in a cover letter instead. If people really want to read this extra information
they will read it in a cover letter as well.

Just supply the '--cover-letter' option when executing the 'git format-patch' command.

Quoted 4 lines

Changes since v1:
* Fixed typos, and made commit message more explicit
* Fixed incorrect usage string
* Some style changes were made

To save yourself the trouble of sieving the "top" or "noteworthy" changes from the new version, you could instead just print the 'range-diff' between the two versions.

You can do:
'git range-diff b1~n1..b1 b2~n2..b2'

Where:

- 'b1' is the first branch; 'n1' is the number of top commits you are taking from 'b1' for
comparison.

- 'b2' is the second branch; 'n2' is the number of top commits you are taking from 'b2' for
comparison.

It will print a very detailed output showing what differences were there commit-wise
amongst the two branches. This can be put at the end of the cover letter. Though, this
isn't necessary if your way seems better to you.

BTW, it would be helpful if you could send mails addressed to me on my other email <[email protected]>.

#10 lore raw

Re: [PATCH v2] [GSoC] submodule--helper: introduce add-clone subcommand

Quoted 17 lines · Shourya Shukla

Hi Atharva!

Quoted 7 lines · Atharva Raykar

Let's add a new "add-clone" 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 clones the repository that is to be added, and checks out to the appropriate branch.

Quoted 5 lines

This is meant to be a faithful conversion that leaves the behaviour of 'submodule add' unchanged. The only minor change is that if a submodule name has been supplied with a name that clashes with a local submodule, the message shown to the user ("A git directory for 'foo' is found locally...") is prepended with "error" for clarity.

Quoted 3 lines

It would be better if commit messages are limited to 72 columns (characters) per line.
Though you can obviously write longer lines on the list no problem.

Good catch. My auto-fill settings had got switched to length 80. I'll be careful next time.

Quoted 10 lines
Quoted 8 lines

This is part of a series of changes that will result in all of 'submodule add' being converted to C.

Quoted 5 lines

I and others before me used to sign off the previous authors using 'Signed-off-by:'. This trailer
has not been used yet so I am not sure if it should be used though I prefer this over the former.
Maybe Christian could comment here?

Yeah, I wasn't sure if I should include an S.o.B without explicit acknowledgement from you and Prathamesh.

Quoted 19 lines
Quoted 12 lines

This is part of a series of changes that will result in all of 'submodule add' being converted to C, which is a more familiar language for Git developers, and paves the way to improve performance and portability.

I have made this patch based on Shourya's patch[1]. I have decided to send the changes in smaller, more reviewable parts. The add-clone subcommand of submodule--helper is an intermediate change, while I work on translating all of the code.

Another subcommand called 'add-config' will also be added in a separate patch that handles the configuration on adding the module.

Quoted 6 lines

After those two changes look good enough, I will be converting whatever is left of 'git submodule add' in the git-submodule.sh past the flag parsing into C code by having one helper subcommand called 'git submodule--helper add' that will incorporate the functionality of the other two helpers, as well. In that patch, the 'add-clone' and 'add-config' subcommands will be removed from the commands array, as they will be called from within the C code itself.

Quoted 8 lines

Seems like a good approach! BTW, if this "extra" message is a bit long like the one above, then
you can put it in a cover letter instead. If people really want to read this extra information
they will read it in a cover letter as well.

Just supply the '--cover-letter' option when executing the 'git format-patch' command.

Not too familiar with the convention here on how long a description warrants a cover letter. Generally in the mailing list I found [PATCH 0/1] labels far more uncommon than [PATCH] for single patch changes, so I went with the common case.

Quoted 22 lines
Quoted 4 lines

Changes since v1:
* Fixed typos, and made commit message more explicit
* Fixed incorrect usage string
* Some style changes were made

To save yourself the trouble of sieving the "top" or "noteworthy" changes from the new version, you could instead just print the 'range-diff' between the two versions.

You can do:
'git range-diff b1~n1..b1 b2~n2..b2'

Where:

- 'b1' is the first branch; 'n1' is the number of top commits you are taking from 'b1' for
comparison.

- 'b2' is the second branch; 'n2' is the number of top commits you are taking from 'b2' for
comparison.

Quoted 5 lines

It will print a very detailed output showing what differences were there commit-wise
amongst the two branches. This can be put at the end of the cover letter. Though, this
isn't necessary if your way seems better to you.

Thanks for the tip. I felt since this change was mostly about code style and naming, a range diff for it felt a little extra.

I liked it more when you used it in a previous v2 of your patch, where the changes were more significant.

Quoted 2 lines

BTW, it would be helpful if you could send mails addressed to me on my other email <[email protected]>.

Got it.