docs: make sure literal "->" isn't converted to arrow
[gitweb.git] / submodule.c
index e9f2b19e1c867b870b0b5f3ef3db3c871fe20689..5294cef641ef74ec525d8d747c82faf0bef7352a 100644 (file)
@@ -9,10 +9,11 @@
 #include "refs.h"
 #include "string-list.h"
 
-struct string_list config_name_for_path;
-struct string_list config_fetch_recurse_submodules_for_name;
-struct string_list config_ignore_for_name;
-static int config_fetch_recurse_submodules;
+static struct string_list config_name_for_path;
+static struct string_list config_fetch_recurse_submodules_for_name;
+static struct string_list config_ignore_for_name;
+static int config_fetch_recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND;
+static struct string_list changed_submodule_paths;
 
 static int add_submodule_odb(const char *path)
 {
@@ -70,7 +71,7 @@ int submodule_config(const char *var, const char *value, void *cb)
        if (!prefixcmp(var, "submodule."))
                return parse_submodule_config_option(var, value);
        else if (!strcmp(var, "fetch.recursesubmodules")) {
-               config_fetch_recurse_submodules = git_config_bool(var, value);
+               config_fetch_recurse_submodules = parse_fetch_recurse_submodules_arg(var, value);
                return 0;
        }
        return 0;
@@ -112,7 +113,7 @@ int parse_submodule_config_option(const char *var, const char *value)
                if (!config)
                        config = string_list_append(&config_fetch_recurse_submodules_for_name,
                                                    strbuf_detach(&submodname, NULL));
-               config->util = git_config_bool(var, value) ? (void *)1 : NULL;
+               config->util = (void *)(intptr_t)parse_fetch_recurse_submodules_arg(var, value);
                strbuf_release(&submodname);
        } else if ((len > 7) && !strcmp(var + len - 7, ".ignore")) {
                if (strcmp(value, "untracked") && strcmp(value, "dirty") &&
@@ -206,6 +207,20 @@ static void print_submodule_summary(struct rev_info *rev, FILE *f,
        strbuf_release(&sb);
 }
 
+int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg)
+{
+       switch (git_config_maybe_bool(opt, arg)) {
+       case 1:
+               return RECURSE_SUBMODULES_ON;
+       case 0:
+               return RECURSE_SUBMODULES_OFF;
+       default:
+               if (!strcmp(arg, "on-demand"))
+                       return RECURSE_SUBMODULES_ON_DEMAND;
+               die("bad %s argument: %s", opt, arg);
+       }
+}
+
 void show_submodule_summary(FILE *f, const char *path,
                unsigned char one[20], unsigned char two[20],
                unsigned dirty_submodule,
@@ -267,27 +282,122 @@ void set_config_fetch_recurse_submodules(int value)
        config_fetch_recurse_submodules = value;
 }
 
+static int is_submodule_commit_present(const char *path, unsigned char sha1[20])
+{
+       int is_present = 0;
+       if (!add_submodule_odb(path) && lookup_commit_reference(sha1)) {
+               /* Even if the submodule is checked out and the commit is
+                * present, make sure it is reachable from a ref. */
+               struct child_process cp;
+               const char *argv[] = {"rev-list", "-n", "1", NULL, "--not", "--all", NULL};
+               struct strbuf buf = STRBUF_INIT;
+
+               argv[3] = sha1_to_hex(sha1);
+               memset(&cp, 0, sizeof(cp));
+               cp.argv = argv;
+               cp.env = local_repo_env;
+               cp.git_cmd = 1;
+               cp.no_stdin = 1;
+               cp.out = -1;
+               cp.dir = path;
+               if (!run_command(&cp) && !strbuf_read(&buf, cp.out, 1024))
+                       is_present = 1;
+
+               close(cp.out);
+               strbuf_release(&buf);
+       }
+       return is_present;
+}
+
+static void submodule_collect_changed_cb(struct diff_queue_struct *q,
+                                        struct diff_options *options,
+                                        void *data)
+{
+       int i;
+       for (i = 0; i < q->nr; i++) {
+               struct diff_filepair *p = q->queue[i];
+               if (!S_ISGITLINK(p->two->mode))
+                       continue;
+
+               if (S_ISGITLINK(p->one->mode)) {
+                       /* NEEDSWORK: We should honor the name configured in
+                        * the .gitmodules file of the commit we are examining
+                        * here to be able to correctly follow submodules
+                        * being moved around. */
+                       struct string_list_item *path;
+                       path = unsorted_string_list_lookup(&changed_submodule_paths, p->two->path);
+                       if (!path && !is_submodule_commit_present(p->two->path, p->two->sha1))
+                               string_list_append(&changed_submodule_paths, xstrdup(p->two->path));
+               } else {
+                       /* Submodule is new or was moved here */
+                       /* NEEDSWORK: When the .git directories of submodules
+                        * live inside the superprojects .git directory some
+                        * day we should fetch new submodules directly into
+                        * that location too when config or options request
+                        * that so they can be checked out from there. */
+                       continue;
+               }
+       }
+}
+
+void check_for_new_submodule_commits(unsigned char new_sha1[20])
+{
+       struct rev_info rev;
+       struct commit *commit;
+       const char *argv[] = {NULL, NULL, "--not", "--all", NULL};
+       int argc = ARRAY_SIZE(argv) - 1;
+
+       init_revisions(&rev, NULL);
+       argv[1] = xstrdup(sha1_to_hex(new_sha1));
+       setup_revisions(argc, argv, &rev, NULL);
+       if (prepare_revision_walk(&rev))
+               die("revision walk setup failed");
+
+       /*
+        * Collect all submodules (whether checked out or not) for which new
+        * commits have been recorded upstream in "changed_submodule_paths".
+        */
+       while ((commit = get_revision(&rev))) {
+               struct commit_list *parent = commit->parents;
+               while (parent) {
+                       struct diff_options diff_opts;
+                       diff_setup(&diff_opts);
+                       diff_opts.output_format |= DIFF_FORMAT_CALLBACK;
+                       diff_opts.format_callback = submodule_collect_changed_cb;
+                       if (diff_setup_done(&diff_opts) < 0)
+                               die("diff_setup_done failed");
+                       diff_tree_sha1(parent->item->object.sha1, commit->object.sha1, "", &diff_opts);
+                       diffcore_std(&diff_opts);
+                       diff_flush(&diff_opts);
+                       parent = parent->next;
+               }
+       }
+       free((char *)argv[1]);
+}
+
 int fetch_populated_submodules(int num_options, const char **options,
-                              const char *prefix, int ignore_config,
+                              const char *prefix, int command_line_option,
                               int quiet)
 {
-       int i, result = 0, argc = 0;
+       int i, result = 0, argc = 0, default_argc;
        struct child_process cp;
        const char **argv;
        struct string_list_item *name_for_path;
        const char *work_tree = get_git_work_tree();
        if (!work_tree)
-               return 0;
+               goto out;
 
        if (!the_index.initialized)
                if (read_cache() < 0)
                        die("index file corrupt");
 
-       /* 4: "fetch" (options) "--submodule-prefix" prefix NULL */
-       argv = xcalloc(num_options + 4, sizeof(const char *));
+       /* 6: "fetch" (options) --recurse-submodules-default default "--submodule-prefix" prefix NULL */
+       argv = xcalloc(num_options + 6, sizeof(const char *));
        argv[argc++] = "fetch";
        for (i = 0; i < num_options; i++)
                argv[argc++] = options[i];
+       argv[argc++] = "--recurse-submodules-default";
+       default_argc = argc++;
        argv[argc++] = "--submodule-prefix";
 
        memset(&cp, 0, sizeof(cp));
@@ -301,7 +411,7 @@ int fetch_populated_submodules(int num_options, const char **options,
                struct strbuf submodule_git_dir = STRBUF_INIT;
                struct strbuf submodule_prefix = STRBUF_INIT;
                struct cache_entry *ce = active_cache[i];
-               const char *git_dir, *name;
+               const char *git_dir, *name, *default_argv;
 
                if (!S_ISGITLINK(ce->ce_mode))
                        continue;
@@ -311,16 +421,31 @@ int fetch_populated_submodules(int num_options, const char **options,
                if (name_for_path)
                        name = name_for_path->util;
 
-               if (!ignore_config) {
+               default_argv = "yes";
+               if (command_line_option == RECURSE_SUBMODULES_DEFAULT) {
                        struct string_list_item *fetch_recurse_submodules_option;
                        fetch_recurse_submodules_option = unsorted_string_list_lookup(&config_fetch_recurse_submodules_for_name, name);
                        if (fetch_recurse_submodules_option) {
-                               if (!fetch_recurse_submodules_option->util)
+                               if ((intptr_t)fetch_recurse_submodules_option->util == RECURSE_SUBMODULES_OFF)
                                        continue;
+                               if ((intptr_t)fetch_recurse_submodules_option->util == RECURSE_SUBMODULES_ON_DEMAND) {
+                                       if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
+                                               continue;
+                                       default_argv = "on-demand";
+                               }
                        } else {
-                               if (!config_fetch_recurse_submodules)
+                               if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_OFF)
                                        continue;
+                               if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND) {
+                                       if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
+                                               continue;
+                                       default_argv = "on-demand";
+                               }
                        }
+               } else if (command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {
+                       if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
+                               continue;
+                       default_argv = "on-demand";
                }
 
                strbuf_addf(&submodule_path, "%s/%s", work_tree, ce->name);
@@ -333,6 +458,7 @@ int fetch_populated_submodules(int num_options, const char **options,
                        if (!quiet)
                                printf("Fetching submodule %s%s\n", prefix, ce->name);
                        cp.dir = submodule_path.buf;
+                       argv[default_argc] = default_argv;
                        argv[argc] = submodule_prefix.buf;
                        if (run_command(&cp))
                                result = 1;
@@ -342,6 +468,8 @@ int fetch_populated_submodules(int num_options, const char **options,
                strbuf_release(&submodule_prefix);
        }
        free(argv);
+out:
+       string_list_clear(&changed_submodule_paths, 1);
        return result;
 }