builtin/merge-base.c

   1 #include "builtin.h"
   2 #include "cache.h"
   3 #include "config.h"
   4 #include "commit.h"
   5 #include "refs.h"
   6 #include "diff.h"
   7 #include "revision.h"
   8 #include "parse-options.h"
   9
  10 static int show_merge_base(struct commit **rev, int rev_nr, int show_all)
  11 {
  12         struct commit_list *result;
  13
  14         result = get_merge_bases_many_dirty(rev[0], rev_nr - 1, rev + 1);
  15
  16         if (!result)
  17                 return 1;
  18
  19         while (result) {
  20                 printf("%s\n", oid_to_hex(&result->item->object.oid));
  21                 if (!show_all)
  22                         return 0;
  23                 result = result->next;
  24         }
  25
  26         return 0;
  27 }
  28
  29 static const char * const merge_base_usage[] = {
  30         N_("git merge-base [-a | --all] <commit> <commit>..."),
  31         N_("git merge-base [-a | --all] --octopus <commit>..."),
  32         N_("git merge-base --independent <commit>..."),
  33         N_("git merge-base --is-ancestor <commit> <commit>"),
  34         N_("git merge-base --fork-point <ref> [<commit>]"),
  35         NULL
  36 };
  37
  38 static struct commit *get_commit_reference(const char *arg)
  39 {
  40         struct object_id revkey;
  41         struct commit *r;
  42
  43         if (get_oid(arg, &revkey))
  44                 die("Not a valid object name %s", arg);
  45         r = lookup_commit_reference(&revkey);
  46         if (!r)
  47                 die("Not a valid commit name %s", arg);
  48
  49         return r;
  50 }
  51
  52 static int handle_independent(int count, const char **args)
  53 {
  54         struct commit_list *revs = NULL;
  55         struct commit_list *result;
  56         int i;
  57
  58         for (i = count - 1; i >= 0; i--)
  59                 commit_list_insert(get_commit_reference(args[i]), &revs);
  60
  61         result = reduce_heads(revs);
  62         if (!result)
  63                 return 1;
  64
  65         while (result) {
  66                 printf("%s\n", oid_to_hex(&result->item->object.oid));
  67                 result = result->next;
  68         }
  69         return 0;
  70 }
  71
  72 static int handle_octopus(int count, const char **args, int show_all)
  73 {
  74         struct commit_list *revs = NULL;
  75         struct commit_list *result;
  76         int i;
  77
  78         for (i = count - 1; i >= 0; i--)
  79                 commit_list_insert(get_commit_reference(args[i]), &revs);
  80
  81         result = reduce_heads(get_octopus_merge_bases(revs));
  82
  83         if (!result)
  84                 return 1;
  85
  86         while (result) {
  87                 printf("%s\n", oid_to_hex(&result->item->object.oid));
  88                 if (!show_all)
  89                         return 0;
  90                 result = result->next;
  91         }
  92
  93         return 0;
  94 }
  95
  96 static int handle_is_ancestor(int argc, const char **argv)
  97 {
  98         struct commit *one, *two;
  99
 100         if (argc != 2)
 101                 die("--is-ancestor takes exactly two commits");
 102         one = get_commit_reference(argv[0]);
 103         two = get_commit_reference(argv[1]);
 104         if (in_merge_bases(one, two))
 105                 return 0;
 106         else
 107                 return 1;
 108 }
 109
 110 struct rev_collect {
 111         struct commit **commit;
 112         int nr;
 113         int alloc;
 114         unsigned int initial : 1;
 115 };
 116
 117 static void add_one_commit(struct object_id *oid, struct rev_collect *revs)
 118 {
 119         struct commit *commit;
 120
 121         if (is_null_oid(oid))
 122                 return;
 123
 124         commit = lookup_commit(oid);
 125         if (!commit ||
 126             (commit->object.flags & TMP_MARK) ||
 127             parse_commit(commit))
 128                 return;
 129
 130         ALLOC_GROW(revs->commit, revs->nr + 1, revs->alloc);
 131         revs->commit[revs->nr++] = commit;
 132         commit->object.flags |= TMP_MARK;
 133 }
 134
 135 static int collect_one_reflog_ent(struct object_id *ooid, struct object_id *noid,
 136                                   const char *ident, timestamp_t timestamp,
 137                                   int tz, const char *message, void *cbdata)
 138 {
 139         struct rev_collect *revs = cbdata;
 140
 141         if (revs->initial) {
 142                 revs->initial = 0;
 143                 add_one_commit(ooid, revs);
 144         }
 145         add_one_commit(noid, revs);
 146         return 0;
 147 }
 148
 149 static int handle_fork_point(int argc, const char **argv)
 150 {
 151         struct object_id oid;
 152         char *refname;
 153         const char *commitname;
 154         struct rev_collect revs;
 155         struct commit *derived;
 156         struct commit_list *bases;
 157         int i, ret = 0;
 158
 159         switch (dwim_ref(argv[0], strlen(argv[0]), oid.hash, &refname)) {
 160         case 0:
 161                 die("No such ref: '%s'", argv[0]);
 162         case 1:
 163                 break; /* good */
 164         default:
 165                 die("Ambiguous refname: '%s'", argv[0]);
 166         }
 167
 168         commitname = (argc == 2) ? argv[1] : "HEAD";
 169         if (get_oid(commitname, &oid))
 170                 die("Not a valid object name: '%s'", commitname);
 171
 172         derived = lookup_commit_reference(&oid);
 173         memset(&revs, 0, sizeof(revs));
 174         revs.initial = 1;
 175         for_each_reflog_ent(refname, collect_one_reflog_ent, &revs);
 176
 177         if (!revs.nr && !get_oid(refname, &oid))
 178                 add_one_commit(&oid, &revs);
 179
 180         for (i = 0; i < revs.nr; i++)
 181                 revs.commit[i]->object.flags &= ~TMP_MARK;
 182
 183         bases = get_merge_bases_many_dirty(derived, revs.nr, revs.commit);
 184
 185         /*
 186          * There should be one and only one merge base, when we found
 187          * a common ancestor among reflog entries.
 188          */
 189         if (!bases || bases->next) {
 190                 ret = 1;
 191                 goto cleanup_return;
 192         }
 193
 194         /* And the found one must be one of the reflog entries */
 195         for (i = 0; i < revs.nr; i++)
 196                 if (&bases->item->object == &revs.commit[i]->object)
 197                         break; /* found */
 198         if (revs.nr <= i) {
 199                 ret = 1; /* not found */
 200                 goto cleanup_return;
 201         }
 202
 203         printf("%s\n", oid_to_hex(&bases->item->object.oid));
 204
 205 cleanup_return:
 206         free_commit_list(bases);
 207         return ret;
 208 }
 209
 210 int cmd_merge_base(int argc, const char **argv, const char *prefix)
 211 {
 212         struct commit **rev;
 213         int rev_nr = 0;
 214         int show_all = 0;
 215         int cmdmode = 0;
 216
 217         struct option options[] = {
 218                 OPT_BOOL('a', "all", &show_all, N_("output all common ancestors")),
 219                 OPT_CMDMODE(0, "octopus", &cmdmode,
 220                             N_("find ancestors for a single n-way merge"), 'o'),
 221                 OPT_CMDMODE(0, "independent", &cmdmode,
 222                             N_("list revs not reachable from others"), 'r'),
 223                 OPT_CMDMODE(0, "is-ancestor", &cmdmode,
 224                             N_("is the first one ancestor of the other?"), 'a'),
 225                 OPT_CMDMODE(0, "fork-point", &cmdmode,
 226                             N_("find where <commit> forked from reflog of <ref>"), 'f'),
 227                 OPT_END()
 228         };
 229
 230         git_config(git_default_config, NULL);
 231         argc = parse_options(argc, argv, prefix, options, merge_base_usage, 0);
 232
 233         if (cmdmode == 'a') {
 234                 if (argc < 2)
 235                         usage_with_options(merge_base_usage, options);
 236                 if (show_all)
 237                         die("--is-ancestor cannot be used with --all");
 238                 return handle_is_ancestor(argc, argv);
 239         }
 240
 241         if (cmdmode == 'r' && show_all)
 242                 die("--independent cannot be used with --all");
 243
 244         if (cmdmode == 'o')
 245                 return handle_octopus(argc, argv, show_all);
 246
 247         if (cmdmode == 'r')
 248                 return handle_independent(argc, argv);
 249
 250         if (cmdmode == 'f') {
 251                 if (argc < 1 || 2 < argc)
 252                         usage_with_options(merge_base_usage, options);
 253                 return handle_fork_point(argc, argv);
 254         }
 255
 256         if (argc < 2)
 257                 usage_with_options(merge_base_usage, options);
 258
 259         ALLOC_ARRAY(rev, argc);
 260         while (argc-- > 0)
 261                 rev[rev_nr++] = get_commit_reference(*argv++);
 262         return show_merge_base(rev, rev_nr, show_all);
 263 }