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