The mechanism used for porting submodule subcommand 'status'
is similar to that used for subcommand 'foreach'.
The function cmd_status from git-submodule is ported to three
functions in the builtin submodule--helper namely: module_status,
for_each_submodule_list and status_submodule.

print_status is also introduced for handling the output of
the subcommand and also to reduce the code size.

Mentored-by: Christian Couder <christian.cou...@gmail.com>
Mentored-by: Stefan Beller <sbel...@google.com>
Signed-off-by: Prathamesh Chavan <pc44...@gmail.com>
---
 builtin/submodule--helper.c | 152 ++++++++++++++++++++++++++++++++++++++++++++
 git-submodule.sh            |  49 +-------------
 2 files changed, 153 insertions(+), 48 deletions(-)

diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c
index 86112ac92..a5de7a0fe 100644
--- a/builtin/submodule--helper.c
+++ b/builtin/submodule--helper.c
@@ -566,6 +566,157 @@ static int module_init(int argc, const char **argv, const 
char *prefix)
        return 0;
 }
 
+struct status_cb {
+       const char *prefix;
+       unsigned int quiet: 1;
+       unsigned int recursive: 1;
+       unsigned int cached: 1;
+};
+#define STATUS_CB_INIT { NULL, 0, 0, 0 }
+
+static void print_status(struct status_cb *info, char state, const char *path,
+                        char *sub_sha1, char *displaypath)
+{
+       if (info->quiet)
+               return;
+
+       printf("%c%s %s", state, sub_sha1, displaypath);
+
+       if (state == ' ' || state == '+') {
+               struct argv_array name_rev_args = ARGV_ARRAY_INIT;
+
+               argv_array_pushl(&name_rev_args, "print-name-rev",
+                                path, sub_sha1, NULL);
+               print_name_rev(name_rev_args.argc, name_rev_args.argv,
+                              info->prefix);
+       } else {
+               printf("\n");
+       }
+}
+
+static void status_submodule(const struct cache_entry *list_item, void 
*cb_data)
+{
+       struct status_cb *info = cb_data;
+       char *sub_sha1 = xstrdup(oid_to_hex(&list_item->oid));
+       char *displaypath;
+       struct argv_array diff_files_args = ARGV_ARRAY_INIT;
+
+       if (!submodule_from_path(null_sha1, list_item->name))
+               die(_("no submodule mapping found in .gitmodules for path 
'%s'"),
+                     list_item->name);
+
+       displaypath = get_submodule_displaypath(list_item->name, info->prefix);
+
+       if (list_item->ce_flags) {
+               print_status(info, 'U', list_item->name,
+                            sha1_to_hex(null_sha1), displaypath);
+               goto cleanup;
+       }
+
+       if (!is_submodule_initialized(list_item->name)) {
+               print_status(info, '-', list_item->name, sub_sha1, displaypath);
+               goto cleanup;
+       }
+
+       argv_array_pushl(&diff_files_args, "diff-files",
+                        "--ignore-submodules=dirty", "--quiet", "--",
+                        list_item->name, NULL);
+
+       if (!cmd_diff_files(diff_files_args.argc, diff_files_args.argv,
+                           info->prefix)) {
+               print_status(info, ' ', list_item->name, sub_sha1, displaypath);
+       } else {
+               if (!info->cached) {
+                       struct child_process cp = CHILD_PROCESS_INIT;
+                       struct strbuf sb = STRBUF_INIT;
+
+                       prepare_submodule_repo_env(&cp.env_array);
+                       cp.git_cmd = 1;
+                       cp.dir = list_item->name;
+
+                       argv_array_pushl(&cp.args, "rev-parse",
+                                        "--verify", "HEAD", NULL);
+
+                       if (capture_command(&cp, &sb, 0))
+                               die(_("could not run 'git rev-parse --verify"
+                                     "HEAD' in submodule %s"),
+                                     list_item->name);
+
+                       strbuf_strip_suffix(&sb, "\n");
+                       print_status(info, '+', list_item->name, sb.buf,
+                                    displaypath);
+                       strbuf_release(&sb);
+               } else {
+                       print_status(info, '+', list_item->name, sub_sha1,
+                                    displaypath);
+               }
+       }
+
+       if (info->recursive) {
+               struct child_process cpr = CHILD_PROCESS_INIT;
+
+               cpr.git_cmd = 1;
+               cpr.dir = list_item->name;
+               prepare_submodule_repo_env(&cpr.env_array);
+
+               argv_array_pushl(&cpr.args, "--super-prefix", displaypath,
+                                "submodule--helper", "status", "--recursive",
+                                NULL);
+
+               if (info->cached)
+                       argv_array_push(&cpr.args, "--cached");
+
+               if (info->quiet)
+                       argv_array_push(&cpr.args, "--quiet");
+
+               if (run_command(&cpr))
+                       die(_("failed to recurse into submodule '%s'"),
+                             list_item->name);
+       }
+
+cleanup:
+       free(displaypath);
+       free(sub_sha1);
+}
+
+static int module_status(int argc, const char **argv, const char *prefix)
+{
+       struct status_cb info = STATUS_CB_INIT;
+       struct pathspec pathspec;
+       struct module_list list = MODULE_LIST_INIT;
+       int quiet = 0;
+       int cached = 0;
+       int recursive = 0;
+
+       struct option module_status_options[] = {
+               OPT__QUIET(&quiet, N_("Suppress submodule status output")),
+               OPT_BOOL(0, "cached", &cached, N_("Use commit stored in the 
index instead of the one stored in the submodule HEAD")),
+               OPT_BOOL(0, "recursive", &recursive, N_("Recurse into nested 
submodules")),
+               OPT_END()
+       };
+
+       const char *const git_submodule_helper_usage[] = {
+               N_("git submodule status [--quiet] [--cached] [--recursive] 
[<path>]"),
+               NULL
+       };
+
+       argc = parse_options(argc, argv, prefix, module_status_options,
+                            git_submodule_helper_usage, 0);
+
+       if (module_list_compute(argc, argv, prefix, &pathspec, &list) < 0)
+               return 1;
+
+       info.prefix = prefix;
+       info.quiet = !!quiet;
+       info.recursive = !!recursive;
+       info.cached = !!cached;
+
+       gitmodules_config();
+       for_each_submodule_list(list, status_submodule, &info);
+
+       return 0;
+}
+
 static int module_name(int argc, const char **argv, const char *prefix)
 {
        const struct submodule *sub;
@@ -1475,6 +1626,7 @@ static struct cmd_struct commands[] = {
        {"foreach", module_foreach, SUPPORT_SUPER_PREFIX},
        {"print-name-rev", print_name_rev, 0},
        {"init", module_init, SUPPORT_SUPER_PREFIX},
+       {"status", module_status, SUPPORT_SUPER_PREFIX},
        {"remote-branch", resolve_remote_submodule_branch, 0},
        {"push-check", push_check, 0},
        {"absorb-git-dirs", absorb_git_dirs, SUPPORT_SUPER_PREFIX},
diff --git a/git-submodule.sh b/git-submodule.sh
index b28a6ba8e..b19d5fa7b 100755
--- a/git-submodule.sh
+++ b/git-submodule.sh
@@ -968,54 +968,7 @@ cmd_status()
                shift
        done
 
-       {
-               git submodule--helper list --prefix "$wt_prefix" "$@" ||
-               echo "#unmatched" $?
-       } |
-       while read -r mode sha1 stage sm_path
-       do
-               die_if_unmatched "$mode" "$sha1"
-               name=$(git submodule--helper name "$sm_path") || exit
-               displaypath=$(git submodule--helper relative-path 
"$prefix$sm_path" "$wt_prefix")
-               if test "$stage" = U
-               then
-                       say "U$sha1 $displaypath"
-                       continue
-               fi
-               if ! git submodule--helper is-active "$sm_path" ||
-               {
-                       ! test -d "$sm_path"/.git &&
-                       ! test -f "$sm_path"/.git
-               }
-               then
-                       say "-$sha1 $displaypath"
-                       continue;
-               fi
-               if git diff-files --ignore-submodules=dirty --quiet -- 
"$sm_path"
-               then
-                       revname=$(git submodule--helper print-name-rev 
"$sm_path" "$sha1")
-                       say " $sha1 $displaypath$revname"
-               else
-                       if test -z "$cached"
-                       then
-                               sha1=$(sanitize_submodule_env; cd "$sm_path" && 
git rev-parse --verify HEAD)
-                       fi
-                       revname=$(git submodule--helper print-name-rev 
"$sm_path" "$sha1")
-                       say "+$sha1 $displaypath$revname"
-               fi
-
-               if test -n "$recursive"
-               then
-                       (
-                               prefix="$displaypath/"
-                               sanitize_submodule_env
-                               wt_prefix=
-                               cd "$sm_path" &&
-                               eval cmd_status
-                       ) ||
-                       die "$(eval_gettext "Failed to recurse into submodule 
path '\$sm_path'")"
-               fi
-       done
+       git ${wt_prefix:+-C "$wt_prefix"} ${prefix:+--super-prefix "$prefix"} 
submodule--helper status ${GIT_QUIET:+--quiet} ${cached:+--cached} 
${recursive:+--recursive} "$@"
 }
 #
 # Sync remote urls for submodules
-- 
2.13.0

Reply via email to