builtin/merge-tree.c

   1 #define USE_THE_INDEX_VARIABLE
   2 #include "builtin.h"
   3 #include "tree-walk.h"
   4 #include "xdiff-interface.h"
   5 #include "help.h"
   6 #include "gettext.h"
   7 #include "hex.h"
   8 #include "commit.h"
   9 #include "commit-reach.h"
  10 #include "merge-ort.h"
  11 #include "object-name.h"
  12 #include "object-store-ll.h"
  13 #include "parse-options.h"
  14 #include "repository.h"
  15 #include "blob.h"
  16 #include "exec-cmd.h"
  17 #include "merge-blobs.h"
  18 #include "quote.h"
  19 #include "tree.h"
  20 #include "config.h"
  21 #include "strvec.h"
  22
  23 static int line_termination = '\n';
  24
  25 struct merge_list {
  26         struct merge_list *next;
  27         struct merge_list *link;        /* other stages for this object */
  28
  29         unsigned int stage : 2;
  30         unsigned int mode;
  31         const char *path;
  32         struct blob *blob;
  33 };
  34
  35 static struct merge_list *merge_result, **merge_result_end = &merge_result;
  36
  37 static void add_merge_entry(struct merge_list *entry)
  38 {
  39         *merge_result_end = entry;
  40         merge_result_end = &entry->next;
  41 }
  42
  43 static void trivial_merge_trees(struct tree_desc t[3], const char *base);
  44
  45 static const char *explanation(struct merge_list *entry)
  46 {
  47         switch (entry->stage) {
  48         case 0:
  49                 return "merged";
  50         case 3:
  51                 return "added in remote";
  52         case 2:
  53                 if (entry->link)
  54                         return "added in both";
  55                 return "added in local";
  56         }
  57
  58         /* Existed in base */
  59         entry = entry->link;
  60         if (!entry)
  61                 return "removed in both";
  62
  63         if (entry->link)
  64                 return "changed in both";
  65
  66         if (entry->stage == 3)
  67                 return "removed in local";
  68         return "removed in remote";
  69 }
  70
  71 static void *result(struct merge_list *entry, unsigned long *size)
  72 {
  73         enum object_type type;
  74         struct blob *base, *our, *their;
  75         const char *path = entry->path;
  76
  77         if (!entry->stage)
  78                 return repo_read_object_file(the_repository,
  79                                              &entry->blob->object.oid, &type,
  80                                              size);
  81         base = NULL;
  82         if (entry->stage == 1) {
  83                 base = entry->blob;
  84                 entry = entry->link;
  85         }
  86         our = NULL;
  87         if (entry && entry->stage == 2) {
  88                 our = entry->blob;
  89                 entry = entry->link;
  90         }
  91         their = NULL;
  92         if (entry)
  93                 their = entry->blob;
  94         return merge_blobs(the_repository->index, path,
  95                            base, our, their, size);
  96 }
  97
  98 static void *origin(struct merge_list *entry, unsigned long *size)
  99 {
 100         enum object_type type;
 101         while (entry) {
 102                 if (entry->stage == 2)
 103                         return repo_read_object_file(the_repository,
 104                                                      &entry->blob->object.oid,
 105                                                      &type, size);
 106                 entry = entry->link;
 107         }
 108         return NULL;
 109 }
 110
 111 static int show_outf(void *priv UNUSED, mmbuffer_t *mb, int nbuf)
 112 {
 113         int i;
 114         for (i = 0; i < nbuf; i++)
 115                 printf("%.*s", (int) mb[i].size, mb[i].ptr);
 116         return 0;
 117 }
 118
 119 static void show_diff(struct merge_list *entry)
 120 {
 121         unsigned long size;
 122         mmfile_t src, dst;
 123         xpparam_t xpp;
 124         xdemitconf_t xecfg;
 125         xdemitcb_t ecb = { .out_line = show_outf };
 126
 127         memset(&xpp, 0, sizeof(xpp));
 128         xpp.flags = 0;
 129         memset(&xecfg, 0, sizeof(xecfg));
 130         xecfg.ctxlen = 3;
 131
 132         src.ptr = origin(entry, &size);
 133         if (!src.ptr)
 134                 size = 0;
 135         src.size = size;
 136         dst.ptr = result(entry, &size);
 137         if (!dst.ptr)
 138                 size = 0;
 139         dst.size = size;
 140         if (xdi_diff(&src, &dst, &xpp, &xecfg, &ecb))
 141                 die("unable to generate diff");
 142         free(src.ptr);
 143         free(dst.ptr);
 144 }
 145
 146 static void show_result_list(struct merge_list *entry)
 147 {
 148         printf("%s\n", explanation(entry));
 149         do {
 150                 struct merge_list *link = entry->link;
 151                 static const char *desc[4] = { "result", "base", "our", "their" };
 152                 printf("  %-6s %o %s %s\n", desc[entry->stage], entry->mode, oid_to_hex(&entry->blob->object.oid), entry->path);
 153                 entry = link;
 154         } while (entry);
 155 }
 156
 157 static void show_result(void)
 158 {
 159         struct merge_list *walk;
 160
 161         walk = merge_result;
 162         while (walk) {
 163                 show_result_list(walk);
 164                 show_diff(walk);
 165                 walk = walk->next;
 166         }
 167 }
 168
 169 /* An empty entry never compares same, not even to another empty entry */
 170 static int same_entry(struct name_entry *a, struct name_entry *b)
 171 {
 172         return  !is_null_oid(&a->oid) &&
 173                 !is_null_oid(&b->oid) &&
 174                 oideq(&a->oid, &b->oid) &&
 175                 a->mode == b->mode;
 176 }
 177
 178 static int both_empty(struct name_entry *a, struct name_entry *b)
 179 {
 180         return is_null_oid(&a->oid) && is_null_oid(&b->oid);
 181 }
 182
 183 static struct merge_list *create_entry(unsigned stage, unsigned mode, const struct object_id *oid, const char *path)
 184 {
 185         struct merge_list *res = xcalloc(1, sizeof(*res));
 186
 187         res->stage = stage;
 188         res->path = path;
 189         res->mode = mode;
 190         res->blob = lookup_blob(the_repository, oid);
 191         return res;
 192 }
 193
 194 static char *traverse_path(const struct traverse_info *info, const struct name_entry *n)
 195 {
 196         struct strbuf buf = STRBUF_INIT;
 197         strbuf_make_traverse_path(&buf, info, n->path, n->pathlen);
 198         return strbuf_detach(&buf, NULL);
 199 }
 200
 201 static void resolve(const struct traverse_info *info, struct name_entry *ours, struct name_entry *result)
 202 {
 203         struct merge_list *orig, *final;
 204         const char *path;
 205
 206         /* If it's already ours, don't bother showing it */
 207         if (!ours)
 208                 return;
 209
 210         path = traverse_path(info, result);
 211         orig = create_entry(2, ours->mode, &ours->oid, path);
 212         final = create_entry(0, result->mode, &result->oid, path);
 213
 214         final->link = orig;
 215
 216         add_merge_entry(final);
 217 }
 218
 219 static void unresolved_directory(const struct traverse_info *info,
 220                                  struct name_entry n[3])
 221 {
 222         struct repository *r = the_repository;
 223         char *newbase;
 224         struct name_entry *p;
 225         struct tree_desc t[3];
 226         void *buf0, *buf1, *buf2;
 227
 228         for (p = n; p < n + 3; p++) {
 229                 if (p->mode && S_ISDIR(p->mode))
 230                         break;
 231         }
 232         if (n + 3 <= p)
 233                 return; /* there is no tree here */
 234
 235         newbase = traverse_path(info, p);
 236
 237 #define ENTRY_OID(e) (((e)->mode && S_ISDIR((e)->mode)) ? &(e)->oid : NULL)
 238         buf0 = fill_tree_descriptor(r, t + 0, ENTRY_OID(n + 0));
 239         buf1 = fill_tree_descriptor(r, t + 1, ENTRY_OID(n + 1));
 240         buf2 = fill_tree_descriptor(r, t + 2, ENTRY_OID(n + 2));
 241 #undef ENTRY_OID
 242
 243         trivial_merge_trees(t, newbase);
 244
 245         free(buf0);
 246         free(buf1);
 247         free(buf2);
 248         free(newbase);
 249 }
 250
 251
 252 static struct merge_list *link_entry(unsigned stage, const struct traverse_info *info, struct name_entry *n, struct merge_list *entry)
 253 {
 254         const char *path;
 255         struct merge_list *link;
 256
 257         if (!n->mode)
 258                 return entry;
 259         if (entry)
 260                 path = entry->path;
 261         else
 262                 path = traverse_path(info, n);
 263         link = create_entry(stage, n->mode, &n->oid, path);
 264         link->link = entry;
 265         return link;
 266 }
 267
 268 static void unresolved(const struct traverse_info *info, struct name_entry n[3])
 269 {
 270         struct merge_list *entry = NULL;
 271         int i;
 272         unsigned dirmask = 0, mask = 0;
 273
 274         for (i = 0; i < 3; i++) {
 275                 mask |= (1 << i);
 276                 /*
 277                  * Treat missing entries as directories so that we return
 278                  * after unresolved_directory has handled this.
 279                  */
 280                 if (!n[i].mode || S_ISDIR(n[i].mode))
 281                         dirmask |= (1 << i);
 282         }
 283
 284         unresolved_directory(info, n);
 285
 286         if (dirmask == mask)
 287                 return;
 288
 289         if (n[2].mode && !S_ISDIR(n[2].mode))
 290                 entry = link_entry(3, info, n + 2, entry);
 291         if (n[1].mode && !S_ISDIR(n[1].mode))
 292                 entry = link_entry(2, info, n + 1, entry);
 293         if (n[0].mode && !S_ISDIR(n[0].mode))
 294                 entry = link_entry(1, info, n + 0, entry);
 295
 296         add_merge_entry(entry);
 297 }
 298
 299 /*
 300  * Merge two trees together (t[1] and t[2]), using a common base (t[0])
 301  * as the origin.
 302  *
 303  * This walks the (sorted) trees in lock-step, checking every possible
 304  * name. Note that directories automatically sort differently from other
 305  * files (see "base_name_compare"), so you'll never see file/directory
 306  * conflicts, because they won't ever compare the same.
 307  *
 308  * IOW, if a directory changes to a filename, it will automatically be
 309  * seen as the directory going away, and the filename being created.
 310  *
 311  * Think of this as a three-way diff.
 312  *
 313  * The output will be either:
 314  *  - successful merge
 315  *       "0 mode sha1 filename"
 316  *    NOTE NOTE NOTE! FIXME! We really really need to walk the index
 317  *    in parallel with this too!
 318  *
 319  *  - conflict:
 320  *      "1 mode sha1 filename"
 321  *      "2 mode sha1 filename"
 322  *      "3 mode sha1 filename"
 323  *    where not all of the 1/2/3 lines may exist, of course.
 324  *
 325  * The successful merge rules are the same as for the three-way merge
 326  * in git-read-tree.
 327  */
 328 static int threeway_callback(int n UNUSED, unsigned long mask,
 329                              unsigned long dirmask UNUSED,
 330                              struct name_entry *entry, struct traverse_info *info)
 331 {
 332         /* Same in both? */
 333         if (same_entry(entry+1, entry+2) || both_empty(entry+1, entry+2)) {
 334                 /* Modified, added or removed identically */
 335                 resolve(info, NULL, entry+1);
 336                 return mask;
 337         }
 338
 339         if (same_entry(entry+0, entry+1)) {
 340                 if (!is_null_oid(&entry[2].oid) && !S_ISDIR(entry[2].mode)) {
 341                         /* We did not touch, they modified -- take theirs */
 342                         resolve(info, entry+1, entry+2);
 343                         return mask;
 344                 }
 345                 /*
 346                  * If we did not touch a directory but they made it
 347                  * into a file, we fall through and unresolved()
 348                  * recurses down.  Likewise for the opposite case.
 349                  */
 350         }
 351
 352         if (same_entry(entry+0, entry+2) || both_empty(entry+0, entry+2)) {
 353                 /* We added, modified or removed, they did not touch -- take ours */
 354                 resolve(info, NULL, entry+1);
 355                 return mask;
 356         }
 357
 358         unresolved(info, entry);
 359         return mask;
 360 }
 361
 362 static void trivial_merge_trees(struct tree_desc t[3], const char *base)
 363 {
 364         struct traverse_info info;
 365
 366         setup_traverse_info(&info, base);
 367         info.fn = threeway_callback;
 368         traverse_trees(&the_index, 3, t, &info);
 369 }
 370
 371 static void *get_tree_descriptor(struct repository *r,
 372                                  struct tree_desc *desc,
 373                                  const char *rev)
 374 {
 375         struct object_id oid;
 376         void *buf;
 377
 378         if (repo_get_oid(r, rev, &oid))
 379                 die("unknown rev %s", rev);
 380         buf = fill_tree_descriptor(r, desc, &oid);
 381         if (!buf)
 382                 die("%s is not a tree", rev);
 383         return buf;
 384 }
 385
 386 static int trivial_merge(const char *base,
 387                          const char *branch1,
 388                          const char *branch2)
 389 {
 390         struct repository *r = the_repository;
 391         struct tree_desc t[3];
 392         void *buf1, *buf2, *buf3;
 393
 394         buf1 = get_tree_descriptor(r, t+0, base);
 395         buf2 = get_tree_descriptor(r, t+1, branch1);
 396         buf3 = get_tree_descriptor(r, t+2, branch2);
 397         trivial_merge_trees(t, "");
 398         free(buf1);
 399         free(buf2);
 400         free(buf3);
 401
 402         show_result();
 403         return 0;
 404 }
 405
 406 enum mode {
 407         MODE_UNKNOWN,
 408         MODE_TRIVIAL,
 409         MODE_REAL,
 410 };
 411
 412 struct merge_tree_options {
 413         int mode;
 414         int allow_unrelated_histories;
 415         int show_messages;
 416         int name_only;
 417         int use_stdin;
 418         struct merge_options merge_options;
 419 };
 420
 421 static int real_merge(struct merge_tree_options *o,
 422                       const char *merge_base,
 423                       const char *branch1, const char *branch2,
 424                       const char *prefix)
 425 {
 426         struct commit *parent1, *parent2;
 427         struct commit_list *merge_bases = NULL;
 428         struct merge_result result = { 0 };
 429         int show_messages = o->show_messages;
 430         struct merge_options opt;
 431
 432         copy_merge_options(&opt, &o->merge_options);
 433         opt.show_rename_progress = 0;
 434
 435         opt.branch1 = branch1;
 436         opt.branch2 = branch2;
 437
 438         if (merge_base) {
 439                 struct tree *base_tree, *parent1_tree, *parent2_tree;
 440
 441                 /*
 442                  * We actually only need the trees because we already
 443                  * have a merge base.
 444                  */
 445                 struct object_id base_oid, head_oid, merge_oid;
 446
 447                 if (repo_get_oid_treeish(the_repository, merge_base, &base_oid))
 448                         die(_("could not parse as tree '%s'"), merge_base);
 449                 base_tree = parse_tree_indirect(&base_oid);
 450                 if (!base_tree)
 451                         die(_("unable to read tree (%s)"), oid_to_hex(&base_oid));
 452                 if (repo_get_oid_treeish(the_repository, branch1, &head_oid))
 453                         die(_("could not parse as tree '%s'"), branch1);
 454                 parent1_tree = parse_tree_indirect(&head_oid);
 455                 if (!parent1_tree)
 456                         die(_("unable to read tree (%s)"), oid_to_hex(&head_oid));
 457                 if (repo_get_oid_treeish(the_repository, branch2, &merge_oid))
 458                         die(_("could not parse as tree '%s'"), branch2);
 459                 parent2_tree = parse_tree_indirect(&merge_oid);
 460                 if (!parent2_tree)
 461                         die(_("unable to read tree (%s)"), oid_to_hex(&merge_oid));
 462
 463                 opt.ancestor = merge_base;
 464                 merge_incore_nonrecursive(&opt, base_tree, parent1_tree, parent2_tree, &result);
 465         } else {
 466                 parent1 = get_merge_parent(branch1);
 467                 if (!parent1)
 468                         help_unknown_ref(branch1, "merge-tree",
 469                                          _("not something we can merge"));
 470
 471                 parent2 = get_merge_parent(branch2);
 472                 if (!parent2)
 473                         help_unknown_ref(branch2, "merge-tree",
 474                                          _("not something we can merge"));
 475
 476                 /*
 477                  * Get the merge bases, in reverse order; see comment above
 478                  * merge_incore_recursive in merge-ort.h
 479                  */
 480                 merge_bases = repo_get_merge_bases(the_repository, parent1,
 481                                                    parent2);
 482                 if (!merge_bases && !o->allow_unrelated_histories)
 483                         die(_("refusing to merge unrelated histories"));
 484                 merge_bases = reverse_commit_list(merge_bases);
 485                 merge_incore_recursive(&opt, merge_bases, parent1, parent2, &result);
 486         }
 487
 488         if (result.clean < 0)
 489                 die(_("failure to merge"));
 490
 491         if (show_messages == -1)
 492                 show_messages = !result.clean;
 493
 494         if (o->use_stdin)
 495                 printf("%d%c", result.clean, line_termination);
 496         printf("%s%c", oid_to_hex(&result.tree->object.oid), line_termination);
 497         if (!result.clean) {
 498                 struct string_list conflicted_files = STRING_LIST_INIT_NODUP;
 499                 const char *last = NULL;
 500                 int i;
 501
 502                 merge_get_conflicted_files(&result, &conflicted_files);
 503                 for (i = 0; i < conflicted_files.nr; i++) {
 504                         const char *name = conflicted_files.items[i].string;
 505                         struct stage_info *c = conflicted_files.items[i].util;
 506                         if (!o->name_only)
 507                                 printf("%06o %s %d\t",
 508                                        c->mode, oid_to_hex(&c->oid), c->stage);
 509                         else if (last && !strcmp(last, name))
 510                                 continue;
 511                         write_name_quoted_relative(
 512                                 name, prefix, stdout, line_termination);
 513                         last = name;
 514                 }
 515                 string_list_clear(&conflicted_files, 1);
 516         }
 517         if (show_messages) {
 518                 putchar(line_termination);
 519                 merge_display_update_messages(&opt, line_termination == '\0',
 520                                               &result);
 521         }
 522         if (o->use_stdin)
 523                 putchar(line_termination);
 524         merge_finalize(&opt, &result);
 525         clear_merge_options(&opt);
 526         return !result.clean; /* result.clean < 0 handled above */
 527 }
 528
 529 int cmd_merge_tree(int argc, const char **argv, const char *prefix)
 530 {
 531         struct merge_tree_options o = { .show_messages = -1 };
 532         struct strvec xopts = STRVEC_INIT;
 533         int expected_remaining_argc;
 534         int original_argc;
 535         const char *merge_base = NULL;
 536
 537         const char * const merge_tree_usage[] = {
 538                 N_("git merge-tree [--write-tree] [<options>] <branch1> <branch2>"),
 539                 N_("git merge-tree [--trivial-merge] <base-tree> <branch1> <branch2>"),
 540                 NULL
 541         };
 542         struct option mt_options[] = {
 543                 OPT_CMDMODE(0, "write-tree", &o.mode,
 544                             N_("do a real merge instead of a trivial merge"),
 545                             MODE_REAL),
 546                 OPT_CMDMODE(0, "trivial-merge", &o.mode,
 547                             N_("do a trivial merge only"), MODE_TRIVIAL),
 548                 OPT_BOOL(0, "messages", &o.show_messages,
 549                          N_("also show informational/conflict messages")),
 550                 OPT_SET_INT('z', NULL, &line_termination,
 551                             N_("separate paths with the NUL character"), '\0'),
 552                 OPT_BOOL_F(0, "name-only",
 553                            &o.name_only,
 554                            N_("list filenames without modes/oids/stages"),
 555                            PARSE_OPT_NONEG),
 556                 OPT_BOOL_F(0, "allow-unrelated-histories",
 557                            &o.allow_unrelated_histories,
 558                            N_("allow merging unrelated histories"),
 559                            PARSE_OPT_NONEG),
 560                 OPT_BOOL_F(0, "stdin",
 561                            &o.use_stdin,
 562                            N_("perform multiple merges, one per line of input"),
 563                            PARSE_OPT_NONEG),
 564                 OPT_STRING(0, "merge-base",
 565                            &merge_base,
 566                            N_("tree-ish"),
 567                            N_("specify a merge-base for the merge")),
 568                 OPT_STRVEC('X', "strategy-option", &xopts, N_("option=value"),
 569                         N_("option for selected merge strategy")),
 570                 OPT_END()
 571         };
 572
 573         /* Init merge options */
 574         init_merge_options(&o.merge_options, the_repository);
 575
 576         /* Parse arguments */
 577         original_argc = argc - 1; /* ignoring argv[0] */
 578         argc = parse_options(argc, argv, prefix, mt_options,
 579                              merge_tree_usage, PARSE_OPT_STOP_AT_NON_OPTION);
 580
 581         if (xopts.nr && o.mode == MODE_TRIVIAL)
 582                 die(_("--trivial-merge is incompatible with all other options"));
 583         for (int x = 0; x < xopts.nr; x++)
 584                 if (parse_merge_opt(&o.merge_options, xopts.v[x]))
 585                         die(_("unknown strategy option: -X%s"), xopts.v[x]);
 586
 587         /* Handle --stdin */
 588         if (o.use_stdin) {
 589                 struct strbuf buf = STRBUF_INIT;
 590
 591                 if (o.mode == MODE_TRIVIAL)
 592                         die(_("--trivial-merge is incompatible with all other options"));
 593                 if (merge_base)
 594                         die(_("--merge-base is incompatible with --stdin"));
 595                 line_termination = '\0';
 596                 while (strbuf_getline_lf(&buf, stdin) != EOF) {
 597                         struct strbuf **split;
 598                         int result;
 599                         const char *input_merge_base = NULL;
 600
 601                         split = strbuf_split(&buf, ' ');
 602                         if (!split[0] || !split[1])
 603                                 die(_("malformed input line: '%s'."), buf.buf);
 604                         strbuf_rtrim(split[0]);
 605                         strbuf_rtrim(split[1]);
 606
 607                         /* parse the merge-base */
 608                         if (!strcmp(split[1]->buf, "--")) {
 609                                 input_merge_base = split[0]->buf;
 610                         }
 611
 612                         if (input_merge_base && split[2] && split[3] && !split[4]) {
 613                                 strbuf_rtrim(split[2]);
 614                                 strbuf_rtrim(split[3]);
 615                                 result = real_merge(&o, input_merge_base, split[2]->buf, split[3]->buf, prefix);
 616                         } else if (!input_merge_base && !split[2]) {
 617                                 result = real_merge(&o, NULL, split[0]->buf, split[1]->buf, prefix);
 618                         } else {
 619                                 die(_("malformed input line: '%s'."), buf.buf);
 620                         }
 621
 622                         if (result < 0)
 623                                 die(_("merging cannot continue; got unclean result of %d"), result);
 624                         strbuf_list_free(split);
 625                 }
 626                 strbuf_release(&buf);
 627                 return 0;
 628         }
 629
 630         /* Figure out which mode to use */
 631         switch (o.mode) {
 632         default:
 633                 BUG("unexpected command mode %d", o.mode);
 634         case MODE_UNKNOWN:
 635                 switch (argc) {
 636                 default:
 637                         usage_with_options(merge_tree_usage, mt_options);
 638                 case 2:
 639                         o.mode = MODE_REAL;
 640                         break;
 641                 case 3:
 642                         o.mode = MODE_TRIVIAL;
 643                         break;
 644                 }
 645                 expected_remaining_argc = argc;
 646                 break;
 647         case MODE_REAL:
 648                 expected_remaining_argc = 2;
 649                 break;
 650         case MODE_TRIVIAL:
 651                 expected_remaining_argc = 3;
 652                 /* Removal of `--trivial-merge` is expected */
 653                 original_argc--;
 654                 break;
 655         }
 656         if (o.mode == MODE_TRIVIAL && argc < original_argc)
 657                 die(_("--trivial-merge is incompatible with all other options"));
 658
 659         if (argc != expected_remaining_argc)
 660                 usage_with_options(merge_tree_usage, mt_options);
 661
 662         git_config(git_default_config, NULL);
 663
 664         /* Do the relevant type of merge */
 665         if (o.mode == MODE_REAL)
 666                 return real_merge(&o, merge_base, argv[0], argv[1], prefix);
 667         else
 668                 return trivial_merge(argv[0], argv[1], argv[2]);
 669 }