Teach read-tree the -n|--dry-run option
[gitweb.git] / revision.c
index 541f09e218ae35c0784a59cea477e87c32bf3a23..7934b2f68bbaf9327ff3957aaa3eb316c2a7fb05 100644 (file)
@@ -1098,35 +1098,34 @@ int handle_revision_arg(const char *arg, struct rev_info *revs,
        return 0;
 }
 
-static void read_pathspec_from_stdin(struct rev_info *revs, struct strbuf *sb, const char ***prune_data)
-{
-       const char **prune = *prune_data;
-       int prune_nr;
-       int prune_alloc;
+struct cmdline_pathspec {
+       int alloc;
+       int nr;
+       const char **path;
+};
 
-       /* count existing ones */
-       if (!prune)
-               prune_nr = 0;
-       else
-               for (prune_nr = 0; prune[prune_nr]; prune_nr++)
-                       ;
-       prune_alloc = prune_nr; /* not really, but we do not know */
+static void append_prune_data(struct cmdline_pathspec *prune, const char **av)
+{
+       while (*av) {
+               ALLOC_GROW(prune->path, prune->nr+1, prune->alloc);
+               prune->path[prune->nr++] = *(av++);
+       }
+}
 
+static void read_pathspec_from_stdin(struct rev_info *revs, struct strbuf *sb,
+                                    struct cmdline_pathspec *prune)
+{
        while (strbuf_getwholeline(sb, stdin, '\n') != EOF) {
                int len = sb->len;
                if (len && sb->buf[len - 1] == '\n')
                        sb->buf[--len] = '\0';
-               ALLOC_GROW(prune, prune_nr+1, prune_alloc);
-               prune[prune_nr++] = xstrdup(sb->buf);
-       }
-       if (prune) {
-               ALLOC_GROW(prune, prune_nr+1, prune_alloc);
-               prune[prune_nr] = NULL;
+               ALLOC_GROW(prune->path, prune->nr+1, prune->alloc);
+               prune->path[prune->nr++] = xstrdup(sb->buf);
        }
-       *prune_data = prune;
 }
 
-static void read_revisions_from_stdin(struct rev_info *revs, const char ***prune)
+static void read_revisions_from_stdin(struct rev_info *revs,
+                                     struct cmdline_pathspec *prune)
 {
        struct strbuf sb;
        int seen_dashdash = 0;
@@ -1180,7 +1179,9 @@ static int handle_revision_opt(struct rev_info *revs, int argc, const char **arg
            !strcmp(arg, "--tags") || !strcmp(arg, "--remotes") ||
            !strcmp(arg, "--reflog") || !strcmp(arg, "--not") ||
            !strcmp(arg, "--no-walk") || !strcmp(arg, "--do-walk") ||
-           !strcmp(arg, "--bisect"))
+           !strcmp(arg, "--bisect") || !prefixcmp(arg, "--glob=") ||
+           !prefixcmp(arg, "--branches=") || !prefixcmp(arg, "--tags=") ||
+           !prefixcmp(arg, "--remotes="))
        {
                unkv[(*unkc)++] = arg;
                return 1;
@@ -1507,32 +1508,67 @@ static int for_each_good_bisect_ref(const char *submodule, each_ref_fn fn, void
        return for_each_ref_in_submodule(submodule, "refs/bisect/good", fn, cb_data);
 }
 
-static void append_prune_data(const char ***prune_data, const char **av)
+static int handle_revision_pseudo_opt(const char *submodule,
+                               struct rev_info *revs,
+                               int argc, const char **argv, int *flags)
 {
-       const char **prune = *prune_data;
-       int prune_nr;
-       int prune_alloc;
+       const char *arg = argv[0];
+       const char *optarg;
+       int argcount;
 
-       if (!prune) {
-               *prune_data = av;
-               return;
+       /*
+        * NOTE!
+        *
+        * Commands like "git shortlog" will not accept the options below
+        * unless parse_revision_opt queues them (as opposed to erroring
+        * out).
+        *
+        * When implementing your new pseudo-option, remember to
+        * register it in the list at the top of handle_revision_opt.
+        */
+       if (!strcmp(arg, "--all")) {
+               handle_refs(submodule, revs, *flags, for_each_ref_submodule);
+               handle_refs(submodule, revs, *flags, head_ref_submodule);
+       } else if (!strcmp(arg, "--branches")) {
+               handle_refs(submodule, revs, *flags, for_each_branch_ref_submodule);
+       } else if (!strcmp(arg, "--bisect")) {
+               handle_refs(submodule, revs, *flags, for_each_bad_bisect_ref);
+               handle_refs(submodule, revs, *flags ^ UNINTERESTING, for_each_good_bisect_ref);
+               revs->bisect = 1;
+       } else if (!strcmp(arg, "--tags")) {
+               handle_refs(submodule, revs, *flags, for_each_tag_ref_submodule);
+       } else if (!strcmp(arg, "--remotes")) {
+               handle_refs(submodule, revs, *flags, for_each_remote_ref_submodule);
+       } else if ((argcount = parse_long_opt("glob", argv, &optarg))) {
+               struct all_refs_cb cb;
+               init_all_refs_cb(&cb, revs, *flags);
+               for_each_glob_ref(handle_one_ref, optarg, &cb);
+               return argcount;
+       } else if (!prefixcmp(arg, "--branches=")) {
+               struct all_refs_cb cb;
+               init_all_refs_cb(&cb, revs, *flags);
+               for_each_glob_ref_in(handle_one_ref, arg + 11, "refs/heads/", &cb);
+       } else if (!prefixcmp(arg, "--tags=")) {
+               struct all_refs_cb cb;
+               init_all_refs_cb(&cb, revs, *flags);
+               for_each_glob_ref_in(handle_one_ref, arg + 7, "refs/tags/", &cb);
+       } else if (!prefixcmp(arg, "--remotes=")) {
+               struct all_refs_cb cb;
+               init_all_refs_cb(&cb, revs, *flags);
+               for_each_glob_ref_in(handle_one_ref, arg + 10, "refs/remotes/", &cb);
+       } else if (!strcmp(arg, "--reflog")) {
+               handle_reflog(revs, *flags);
+       } else if (!strcmp(arg, "--not")) {
+               *flags ^= UNINTERESTING;
+       } else if (!strcmp(arg, "--no-walk")) {
+               revs->no_walk = 1;
+       } else if (!strcmp(arg, "--do-walk")) {
+               revs->no_walk = 0;
+       } else {
+               return 0;
        }
 
-       /* count existing ones */
-       for (prune_nr = 0; prune[prune_nr]; prune_nr++)
-               ;
-       prune_alloc = prune_nr; /* not really, but we do not know */
-
-       while (*av) {
-               ALLOC_GROW(prune, prune_nr+1, prune_alloc);
-               prune[prune_nr++] = *av;
-               av++;
-       }
-       if (prune) {
-               ALLOC_GROW(prune, prune_nr+1, prune_alloc);
-               prune[prune_nr] = NULL;
-       }
-       *prune_data = prune;
+       return 1;
 }
 
 /*
@@ -1545,11 +1581,10 @@ static void append_prune_data(const char ***prune_data, const char **av)
 int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct setup_revision_opt *opt)
 {
        int i, flags, left, seen_dashdash, read_from_stdin, got_rev_arg = 0;
-       const char **prune_data = NULL;
+       struct cmdline_pathspec prune_data;
        const char *submodule = NULL;
-       const char *optarg;
-       int argcount;
 
+       memset(&prune_data, 0, sizeof(prune_data));
        if (opt)
                submodule = opt->submodule;
 
@@ -1562,7 +1597,7 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct s
                argv[i] = NULL;
                argc = i;
                if (argv[i + 1])
-                       prune_data = argv + i + 1;
+                       append_prune_data(&prune_data, argv + i + 1);
                seen_dashdash = 1;
                break;
        }
@@ -1575,70 +1610,14 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct s
                if (*arg == '-') {
                        int opts;
 
-                       if (!strcmp(arg, "--all")) {
-                               handle_refs(submodule, revs, flags, for_each_ref_submodule);
-                               handle_refs(submodule, revs, flags, head_ref_submodule);
-                               continue;
-                       }
-                       if (!strcmp(arg, "--branches")) {
-                               handle_refs(submodule, revs, flags, for_each_branch_ref_submodule);
-                               continue;
-                       }
-                       if (!strcmp(arg, "--bisect")) {
-                               handle_refs(submodule, revs, flags, for_each_bad_bisect_ref);
-                               handle_refs(submodule, revs, flags ^ UNINTERESTING, for_each_good_bisect_ref);
-                               revs->bisect = 1;
-                               continue;
-                       }
-                       if (!strcmp(arg, "--tags")) {
-                               handle_refs(submodule, revs, flags, for_each_tag_ref_submodule);
-                               continue;
-                       }
-                       if (!strcmp(arg, "--remotes")) {
-                               handle_refs(submodule, revs, flags, for_each_remote_ref_submodule);
-                               continue;
-                       }
-                       if ((argcount = parse_long_opt("glob", argv + i, &optarg))) {
-                               struct all_refs_cb cb;
-                               i += argcount - 1;
-                               init_all_refs_cb(&cb, revs, flags);
-                               for_each_glob_ref(handle_one_ref, optarg, &cb);
-                               continue;
-                       }
-                       if (!prefixcmp(arg, "--branches=")) {
-                               struct all_refs_cb cb;
-                               init_all_refs_cb(&cb, revs, flags);
-                               for_each_glob_ref_in(handle_one_ref, arg + 11, "refs/heads/", &cb);
-                               continue;
-                       }
-                       if (!prefixcmp(arg, "--tags=")) {
-                               struct all_refs_cb cb;
-                               init_all_refs_cb(&cb, revs, flags);
-                               for_each_glob_ref_in(handle_one_ref, arg + 7, "refs/tags/", &cb);
-                               continue;
-                       }
-                       if (!prefixcmp(arg, "--remotes=")) {
-                               struct all_refs_cb cb;
-                               init_all_refs_cb(&cb, revs, flags);
-                               for_each_glob_ref_in(handle_one_ref, arg + 10, "refs/remotes/", &cb);
-                               continue;
-                       }
-                       if (!strcmp(arg, "--reflog")) {
-                               handle_reflog(revs, flags);
-                               continue;
-                       }
-                       if (!strcmp(arg, "--not")) {
-                               flags ^= UNINTERESTING;
-                               continue;
-                       }
-                       if (!strcmp(arg, "--no-walk")) {
-                               revs->no_walk = 1;
-                               continue;
-                       }
-                       if (!strcmp(arg, "--do-walk")) {
-                               revs->no_walk = 0;
+                       opts = handle_revision_pseudo_opt(submodule,
+                                               revs, argc - i, argv + i,
+                                               &flags);
+                       if (opts > 0) {
+                               i += opts - 1;
                                continue;
                        }
+
                        if (!strcmp(arg, "--stdin")) {
                                if (revs->disable_stdin) {
                                        argv[left++] = arg;
@@ -1681,8 +1660,26 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct s
                        got_rev_arg = 1;
        }
 
-       if (prune_data)
-               init_pathspec(&revs->prune_data, get_pathspec(revs->prefix, prune_data));
+       if (prune_data.nr) {
+               /*
+                * If we need to introduce the magic "a lone ':' means no
+                * pathspec whatsoever", here is the place to do so.
+                *
+                * if (prune_data.nr == 1 && !strcmp(prune_data[0], ":")) {
+                *      prune_data.nr = 0;
+                *      prune_data.alloc = 0;
+                *      free(prune_data.path);
+                *      prune_data.path = NULL;
+                * } else {
+                *      terminate prune_data.alloc with NULL and
+                *      call init_pathspec() to set revs->prune_data here.
+                * }
+                */
+               ALLOC_GROW(prune_data.path, prune_data.nr+1, prune_data.alloc);
+               prune_data.path[prune_data.nr++] = NULL;
+               init_pathspec(&revs->prune_data,
+                             get_pathspec(revs->prefix, prune_data.path));
+       }
 
        if (revs->def == NULL)
                revs->def = opt ? opt->def : NULL;