Merge branch 'pk/rebase-in-c-6-final'
[git] / notes-merge.c
1 #include "cache.h"
2 #include "commit.h"
3 #include "refs.h"
4 #include "object-store.h"
5 #include "repository.h"
6 #include "diff.h"
7 #include "diffcore.h"
8 #include "xdiff-interface.h"
9 #include "ll-merge.h"
10 #include "dir.h"
11 #include "notes.h"
12 #include "notes-merge.h"
13 #include "strbuf.h"
14 #include "notes-utils.h"
15 #include "commit-reach.h"
16
17 struct notes_merge_pair {
18         struct object_id obj, base, local, remote;
19 };
20
21 void init_notes_merge_options(struct notes_merge_options *o)
22 {
23         memset(o, 0, sizeof(struct notes_merge_options));
24         strbuf_init(&(o->commit_msg), 0);
25         o->verbosity = NOTES_MERGE_VERBOSITY_DEFAULT;
26 }
27
28 static int path_to_oid(const char *path, struct object_id *oid)
29 {
30         char hex_oid[GIT_SHA1_HEXSZ];
31         int i = 0;
32         while (*path && i < GIT_SHA1_HEXSZ) {
33                 if (*path != '/')
34                         hex_oid[i++] = *path;
35                 path++;
36         }
37         if (*path || i != GIT_SHA1_HEXSZ)
38                 return -1;
39         return get_oid_hex(hex_oid, oid);
40 }
41
42 static int verify_notes_filepair(struct diff_filepair *p, struct object_id *oid)
43 {
44         switch (p->status) {
45         case DIFF_STATUS_MODIFIED:
46                 assert(p->one->mode == p->two->mode);
47                 assert(!is_null_oid(&p->one->oid));
48                 assert(!is_null_oid(&p->two->oid));
49                 break;
50         case DIFF_STATUS_ADDED:
51                 assert(is_null_oid(&p->one->oid));
52                 break;
53         case DIFF_STATUS_DELETED:
54                 assert(is_null_oid(&p->two->oid));
55                 break;
56         default:
57                 return -1;
58         }
59         assert(!strcmp(p->one->path, p->two->path));
60         return path_to_oid(p->one->path, oid);
61 }
62
63 static struct notes_merge_pair *find_notes_merge_pair_pos(
64                 struct notes_merge_pair *list, int len, struct object_id *obj,
65                 int insert_new, int *occupied)
66 {
67         /*
68          * Both diff_tree_remote() and diff_tree_local() tend to process
69          * merge_pairs in ascending order. Therefore, cache last returned
70          * index, and search sequentially from there until the appropriate
71          * position is found.
72          *
73          * Since inserts only happen from diff_tree_remote() (which mainly
74          * _appends_), we don't care that inserting into the middle of the
75          * list is expensive (using memmove()).
76          */
77         static int last_index;
78         int i = last_index < len ? last_index : len - 1;
79         int prev_cmp = 0, cmp = -1;
80         while (i >= 0 && i < len) {
81                 cmp = oidcmp(obj, &list[i].obj);
82                 if (!cmp) /* obj belongs @ i */
83                         break;
84                 else if (cmp < 0 && prev_cmp <= 0) /* obj belongs < i */
85                         i--;
86                 else if (cmp < 0) /* obj belongs between i-1 and i */
87                         break;
88                 else if (cmp > 0 && prev_cmp >= 0) /* obj belongs > i */
89                         i++;
90                 else /* if (cmp > 0) */ { /* obj belongs between i and i+1 */
91                         i++;
92                         break;
93                 }
94                 prev_cmp = cmp;
95         }
96         if (i < 0)
97                 i = 0;
98         /* obj belongs at, or immediately preceding, index i (0 <= i <= len) */
99
100         if (!cmp)
101                 *occupied = 1;
102         else {
103                 *occupied = 0;
104                 if (insert_new && i < len) {
105                         MOVE_ARRAY(list + i + 1, list + i, len - i);
106                         memset(list + i, 0, sizeof(struct notes_merge_pair));
107                 }
108         }
109         last_index = i;
110         return list + i;
111 }
112
113 static struct object_id uninitialized = {
114         "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" \
115         "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
116 };
117
118 static struct notes_merge_pair *diff_tree_remote(struct notes_merge_options *o,
119                                                  const struct object_id *base,
120                                                  const struct object_id *remote,
121                                                  int *num_changes)
122 {
123         struct diff_options opt;
124         struct notes_merge_pair *changes;
125         int i, len = 0;
126
127         trace_printf("\tdiff_tree_remote(base = %.7s, remote = %.7s)\n",
128                oid_to_hex(base), oid_to_hex(remote));
129
130         repo_diff_setup(the_repository, &opt);
131         opt.flags.recursive = 1;
132         opt.output_format = DIFF_FORMAT_NO_OUTPUT;
133         diff_setup_done(&opt);
134         diff_tree_oid(base, remote, "", &opt);
135         diffcore_std(&opt);
136
137         changes = xcalloc(diff_queued_diff.nr, sizeof(struct notes_merge_pair));
138
139         for (i = 0; i < diff_queued_diff.nr; i++) {
140                 struct diff_filepair *p = diff_queued_diff.queue[i];
141                 struct notes_merge_pair *mp;
142                 int occupied;
143                 struct object_id obj;
144
145                 if (verify_notes_filepair(p, &obj)) {
146                         trace_printf("\t\tCannot merge entry '%s' (%c): "
147                                "%.7s -> %.7s. Skipping!\n", p->one->path,
148                                p->status, oid_to_hex(&p->one->oid),
149                                oid_to_hex(&p->two->oid));
150                         continue;
151                 }
152                 mp = find_notes_merge_pair_pos(changes, len, &obj, 1, &occupied);
153                 if (occupied) {
154                         /* We've found an addition/deletion pair */
155                         assert(oideq(&mp->obj, &obj));
156                         if (is_null_oid(&p->one->oid)) { /* addition */
157                                 assert(is_null_oid(&mp->remote));
158                                 oidcpy(&mp->remote, &p->two->oid);
159                         } else if (is_null_oid(&p->two->oid)) { /* deletion */
160                                 assert(is_null_oid(&mp->base));
161                                 oidcpy(&mp->base, &p->one->oid);
162                         } else
163                                 assert(!"Invalid existing change recorded");
164                 } else {
165                         oidcpy(&mp->obj, &obj);
166                         oidcpy(&mp->base, &p->one->oid);
167                         oidcpy(&mp->local, &uninitialized);
168                         oidcpy(&mp->remote, &p->two->oid);
169                         len++;
170                 }
171                 trace_printf("\t\tStored remote change for %s: %.7s -> %.7s\n",
172                        oid_to_hex(&mp->obj), oid_to_hex(&mp->base),
173                        oid_to_hex(&mp->remote));
174         }
175         diff_flush(&opt);
176         clear_pathspec(&opt.pathspec);
177
178         *num_changes = len;
179         return changes;
180 }
181
182 static void diff_tree_local(struct notes_merge_options *o,
183                             struct notes_merge_pair *changes, int len,
184                             const struct object_id *base,
185                             const struct object_id *local)
186 {
187         struct diff_options opt;
188         int i;
189
190         trace_printf("\tdiff_tree_local(len = %i, base = %.7s, local = %.7s)\n",
191                len, oid_to_hex(base), oid_to_hex(local));
192
193         repo_diff_setup(the_repository, &opt);
194         opt.flags.recursive = 1;
195         opt.output_format = DIFF_FORMAT_NO_OUTPUT;
196         diff_setup_done(&opt);
197         diff_tree_oid(base, local, "", &opt);
198         diffcore_std(&opt);
199
200         for (i = 0; i < diff_queued_diff.nr; i++) {
201                 struct diff_filepair *p = diff_queued_diff.queue[i];
202                 struct notes_merge_pair *mp;
203                 int match;
204                 struct object_id obj;
205
206                 if (verify_notes_filepair(p, &obj)) {
207                         trace_printf("\t\tCannot merge entry '%s' (%c): "
208                                "%.7s -> %.7s. Skipping!\n", p->one->path,
209                                p->status, oid_to_hex(&p->one->oid),
210                                oid_to_hex(&p->two->oid));
211                         continue;
212                 }
213                 mp = find_notes_merge_pair_pos(changes, len, &obj, 0, &match);
214                 if (!match) {
215                         trace_printf("\t\tIgnoring local-only change for %s: "
216                                "%.7s -> %.7s\n", oid_to_hex(&obj),
217                                oid_to_hex(&p->one->oid),
218                                oid_to_hex(&p->two->oid));
219                         continue;
220                 }
221
222                 assert(oideq(&mp->obj, &obj));
223                 if (is_null_oid(&p->two->oid)) { /* deletion */
224                         /*
225                          * Either this is a true deletion (1), or it is part
226                          * of an A/D pair (2), or D/A pair (3):
227                          *
228                          * (1) mp->local is uninitialized; set it to null_sha1
229                          * (2) mp->local is not uninitialized; don't touch it
230                          * (3) mp->local is uninitialized; set it to null_sha1
231                          *     (will be overwritten by following addition)
232                          */
233                         if (oideq(&mp->local, &uninitialized))
234                                 oidclr(&mp->local);
235                 } else if (is_null_oid(&p->one->oid)) { /* addition */
236                         /*
237                          * Either this is a true addition (1), or it is part
238                          * of an A/D pair (2), or D/A pair (3):
239                          *
240                          * (1) mp->local is uninitialized; set to p->two->sha1
241                          * (2) mp->local is uninitialized; set to p->two->sha1
242                          * (3) mp->local is null_sha1;     set to p->two->sha1
243                          */
244                         assert(is_null_oid(&mp->local) ||
245                                oideq(&mp->local, &uninitialized));
246                         oidcpy(&mp->local, &p->two->oid);
247                 } else { /* modification */
248                         /*
249                          * This is a true modification. p->one->sha1 shall
250                          * match mp->base, and mp->local shall be uninitialized.
251                          * Set mp->local to p->two->sha1.
252                          */
253                         assert(oideq(&p->one->oid, &mp->base));
254                         assert(oideq(&mp->local, &uninitialized));
255                         oidcpy(&mp->local, &p->two->oid);
256                 }
257                 trace_printf("\t\tStored local change for %s: %.7s -> %.7s\n",
258                        oid_to_hex(&mp->obj), oid_to_hex(&mp->base),
259                        oid_to_hex(&mp->local));
260         }
261         diff_flush(&opt);
262         clear_pathspec(&opt.pathspec);
263 }
264
265 static void check_notes_merge_worktree(struct notes_merge_options *o)
266 {
267         if (!o->has_worktree) {
268                 /*
269                  * Must establish NOTES_MERGE_WORKTREE.
270                  * Abort if NOTES_MERGE_WORKTREE already exists
271                  */
272                 if (file_exists(git_path(NOTES_MERGE_WORKTREE)) &&
273                     !is_empty_dir(git_path(NOTES_MERGE_WORKTREE))) {
274                         if (advice_resolve_conflict)
275                                 die(_("You have not concluded your previous "
276                                     "notes merge (%s exists).\nPlease, use "
277                                     "'git notes merge --commit' or 'git notes "
278                                     "merge --abort' to commit/abort the "
279                                     "previous merge before you start a new "
280                                     "notes merge."), git_path("NOTES_MERGE_*"));
281                         else
282                                 die(_("You have not concluded your notes merge "
283                                     "(%s exists)."), git_path("NOTES_MERGE_*"));
284                 }
285
286                 if (safe_create_leading_directories_const(git_path(
287                                 NOTES_MERGE_WORKTREE "/.test")))
288                         die_errno("unable to create directory %s",
289                                   git_path(NOTES_MERGE_WORKTREE));
290                 o->has_worktree = 1;
291         } else if (!file_exists(git_path(NOTES_MERGE_WORKTREE)))
292                 /* NOTES_MERGE_WORKTREE should already be established */
293                 die("missing '%s'. This should not happen",
294                     git_path(NOTES_MERGE_WORKTREE));
295 }
296
297 static void write_buf_to_worktree(const struct object_id *obj,
298                                   const char *buf, unsigned long size)
299 {
300         int fd;
301         char *path = git_pathdup(NOTES_MERGE_WORKTREE "/%s", oid_to_hex(obj));
302         if (safe_create_leading_directories_const(path))
303                 die_errno("unable to create directory for '%s'", path);
304
305         fd = xopen(path, O_WRONLY | O_EXCL | O_CREAT, 0666);
306
307         while (size > 0) {
308                 ssize_t ret = write_in_full(fd, buf, size);
309                 if (ret < 0) {
310                         /* Ignore epipe */
311                         if (errno == EPIPE)
312                                 break;
313                         die_errno("notes-merge");
314                 }
315                 size -= ret;
316                 buf += ret;
317         }
318
319         close(fd);
320         free(path);
321 }
322
323 static void write_note_to_worktree(const struct object_id *obj,
324                                    const struct object_id *note)
325 {
326         enum object_type type;
327         unsigned long size;
328         void *buf = read_object_file(note, &type, &size);
329
330         if (!buf)
331                 die("cannot read note %s for object %s",
332                     oid_to_hex(note), oid_to_hex(obj));
333         if (type != OBJ_BLOB)
334                 die("blob expected in note %s for object %s",
335                     oid_to_hex(note), oid_to_hex(obj));
336         write_buf_to_worktree(obj, buf, size);
337         free(buf);
338 }
339
340 static int ll_merge_in_worktree(struct notes_merge_options *o,
341                                 struct notes_merge_pair *p)
342 {
343         mmbuffer_t result_buf;
344         mmfile_t base, local, remote;
345         int status;
346
347         read_mmblob(&base, &p->base);
348         read_mmblob(&local, &p->local);
349         read_mmblob(&remote, &p->remote);
350
351         status = ll_merge(&result_buf, oid_to_hex(&p->obj), &base, NULL,
352                           &local, o->local_ref, &remote, o->remote_ref,
353                           &the_index, NULL);
354
355         free(base.ptr);
356         free(local.ptr);
357         free(remote.ptr);
358
359         if ((status < 0) || !result_buf.ptr)
360                 die("Failed to execute internal merge");
361
362         write_buf_to_worktree(&p->obj, result_buf.ptr, result_buf.size);
363         free(result_buf.ptr);
364
365         return status;
366 }
367
368 static int merge_one_change_manual(struct notes_merge_options *o,
369                                    struct notes_merge_pair *p,
370                                    struct notes_tree *t)
371 {
372         const char *lref = o->local_ref ? o->local_ref : "local version";
373         const char *rref = o->remote_ref ? o->remote_ref : "remote version";
374
375         trace_printf("\t\t\tmerge_one_change_manual(obj = %.7s, base = %.7s, "
376                "local = %.7s, remote = %.7s)\n",
377                oid_to_hex(&p->obj), oid_to_hex(&p->base),
378                oid_to_hex(&p->local), oid_to_hex(&p->remote));
379
380         /* add "Conflicts:" section to commit message first time through */
381         if (!o->has_worktree)
382                 strbuf_addstr(&(o->commit_msg), "\n\nConflicts:\n");
383
384         strbuf_addf(&(o->commit_msg), "\t%s\n", oid_to_hex(&p->obj));
385
386         if (o->verbosity >= 2)
387                 printf("Auto-merging notes for %s\n", oid_to_hex(&p->obj));
388         check_notes_merge_worktree(o);
389         if (is_null_oid(&p->local)) {
390                 /* D/F conflict, checkout p->remote */
391                 assert(!is_null_oid(&p->remote));
392                 if (o->verbosity >= 1)
393                         printf("CONFLICT (delete/modify): Notes for object %s "
394                                 "deleted in %s and modified in %s. Version from %s "
395                                 "left in tree.\n",
396                                 oid_to_hex(&p->obj), lref, rref, rref);
397                 write_note_to_worktree(&p->obj, &p->remote);
398         } else if (is_null_oid(&p->remote)) {
399                 /* D/F conflict, checkout p->local */
400                 assert(!is_null_oid(&p->local));
401                 if (o->verbosity >= 1)
402                         printf("CONFLICT (delete/modify): Notes for object %s "
403                                 "deleted in %s and modified in %s. Version from %s "
404                                 "left in tree.\n",
405                                 oid_to_hex(&p->obj), rref, lref, lref);
406                 write_note_to_worktree(&p->obj, &p->local);
407         } else {
408                 /* "regular" conflict, checkout result of ll_merge() */
409                 const char *reason = "content";
410                 if (is_null_oid(&p->base))
411                         reason = "add/add";
412                 assert(!is_null_oid(&p->local));
413                 assert(!is_null_oid(&p->remote));
414                 if (o->verbosity >= 1)
415                         printf("CONFLICT (%s): Merge conflict in notes for "
416                                 "object %s\n", reason,
417                                 oid_to_hex(&p->obj));
418                 ll_merge_in_worktree(o, p);
419         }
420
421         trace_printf("\t\t\tremoving from partial merge result\n");
422         remove_note(t, p->obj.hash);
423
424         return 1;
425 }
426
427 static int merge_one_change(struct notes_merge_options *o,
428                             struct notes_merge_pair *p, struct notes_tree *t)
429 {
430         /*
431          * Return 0 if change is successfully resolved (stored in notes_tree).
432          * Return 1 is change results in a conflict (NOT stored in notes_tree,
433          * but instead written to NOTES_MERGE_WORKTREE with conflict markers).
434          */
435         switch (o->strategy) {
436         case NOTES_MERGE_RESOLVE_MANUAL:
437                 return merge_one_change_manual(o, p, t);
438         case NOTES_MERGE_RESOLVE_OURS:
439                 if (o->verbosity >= 2)
440                         printf("Using local notes for %s\n",
441                                                 oid_to_hex(&p->obj));
442                 /* nothing to do */
443                 return 0;
444         case NOTES_MERGE_RESOLVE_THEIRS:
445                 if (o->verbosity >= 2)
446                         printf("Using remote notes for %s\n",
447                                                 oid_to_hex(&p->obj));
448                 if (add_note(t, &p->obj, &p->remote, combine_notes_overwrite))
449                         BUG("combine_notes_overwrite failed");
450                 return 0;
451         case NOTES_MERGE_RESOLVE_UNION:
452                 if (o->verbosity >= 2)
453                         printf("Concatenating local and remote notes for %s\n",
454                                                         oid_to_hex(&p->obj));
455                 if (add_note(t, &p->obj, &p->remote, combine_notes_concatenate))
456                         die("failed to concatenate notes "
457                             "(combine_notes_concatenate)");
458                 return 0;
459         case NOTES_MERGE_RESOLVE_CAT_SORT_UNIQ:
460                 if (o->verbosity >= 2)
461                         printf("Concatenating unique lines in local and remote "
462                                 "notes for %s\n", oid_to_hex(&p->obj));
463                 if (add_note(t, &p->obj, &p->remote, combine_notes_cat_sort_uniq))
464                         die("failed to concatenate notes "
465                             "(combine_notes_cat_sort_uniq)");
466                 return 0;
467         }
468         die("Unknown strategy (%i).", o->strategy);
469 }
470
471 static int merge_changes(struct notes_merge_options *o,
472                          struct notes_merge_pair *changes, int *num_changes,
473                          struct notes_tree *t)
474 {
475         int i, conflicts = 0;
476
477         trace_printf("\tmerge_changes(num_changes = %i)\n", *num_changes);
478         for (i = 0; i < *num_changes; i++) {
479                 struct notes_merge_pair *p = changes + i;
480                 trace_printf("\t\t%.7s: %.7s -> %.7s/%.7s\n",
481                        oid_to_hex(&p->obj), oid_to_hex(&p->base),
482                        oid_to_hex(&p->local),
483                        oid_to_hex(&p->remote));
484
485                 if (oideq(&p->base, &p->remote)) {
486                         /* no remote change; nothing to do */
487                         trace_printf("\t\t\tskipping (no remote change)\n");
488                 } else if (oideq(&p->local, &p->remote)) {
489                         /* same change in local and remote; nothing to do */
490                         trace_printf("\t\t\tskipping (local == remote)\n");
491                 } else if (oideq(&p->local, &uninitialized) ||
492                            oideq(&p->local, &p->base)) {
493                         /* no local change; adopt remote change */
494                         trace_printf("\t\t\tno local change, adopted remote\n");
495                         if (add_note(t, &p->obj, &p->remote,
496                                      combine_notes_overwrite))
497                                 BUG("combine_notes_overwrite failed");
498                 } else {
499                         /* need file-level merge between local and remote */
500                         trace_printf("\t\t\tneed content-level merge\n");
501                         conflicts += merge_one_change(o, p, t);
502                 }
503         }
504
505         return conflicts;
506 }
507
508 static int merge_from_diffs(struct notes_merge_options *o,
509                             const struct object_id *base,
510                             const struct object_id *local,
511                             const struct object_id *remote,
512                             struct notes_tree *t)
513 {
514         struct notes_merge_pair *changes;
515         int num_changes, conflicts;
516
517         trace_printf("\tmerge_from_diffs(base = %.7s, local = %.7s, "
518                "remote = %.7s)\n", oid_to_hex(base), oid_to_hex(local),
519                oid_to_hex(remote));
520
521         changes = diff_tree_remote(o, base, remote, &num_changes);
522         diff_tree_local(o, changes, num_changes, base, local);
523
524         conflicts = merge_changes(o, changes, &num_changes, t);
525         free(changes);
526
527         if (o->verbosity >= 4)
528                 printf(t->dirty ?
529                        "Merge result: %i unmerged notes and a dirty notes tree\n" :
530                        "Merge result: %i unmerged notes and a clean notes tree\n",
531                        conflicts);
532
533         return conflicts ? -1 : 1;
534 }
535
536 int notes_merge(struct notes_merge_options *o,
537                 struct notes_tree *local_tree,
538                 struct object_id *result_oid)
539 {
540         struct object_id local_oid, remote_oid;
541         struct commit *local, *remote;
542         struct commit_list *bases = NULL;
543         const struct object_id *base_oid, *base_tree_oid;
544         int result = 0;
545
546         assert(o->local_ref && o->remote_ref);
547         assert(!strcmp(o->local_ref, local_tree->ref));
548         oidclr(result_oid);
549
550         trace_printf("notes_merge(o->local_ref = %s, o->remote_ref = %s)\n",
551                o->local_ref, o->remote_ref);
552
553         /* Dereference o->local_ref into local_sha1 */
554         if (read_ref_full(o->local_ref, 0, &local_oid, NULL))
555                 die("Failed to resolve local notes ref '%s'", o->local_ref);
556         else if (!check_refname_format(o->local_ref, 0) &&
557                 is_null_oid(&local_oid))
558                 local = NULL; /* local_oid == null_oid indicates unborn ref */
559         else if (!(local = lookup_commit_reference(the_repository, &local_oid)))
560                 die("Could not parse local commit %s (%s)",
561                     oid_to_hex(&local_oid), o->local_ref);
562         trace_printf("\tlocal commit: %.7s\n", oid_to_hex(&local_oid));
563
564         /* Dereference o->remote_ref into remote_oid */
565         if (get_oid(o->remote_ref, &remote_oid)) {
566                 /*
567                  * Failed to get remote_oid. If o->remote_ref looks like an
568                  * unborn ref, perform the merge using an empty notes tree.
569                  */
570                 if (!check_refname_format(o->remote_ref, 0)) {
571                         oidclr(&remote_oid);
572                         remote = NULL;
573                 } else {
574                         die("Failed to resolve remote notes ref '%s'",
575                             o->remote_ref);
576                 }
577         } else if (!(remote = lookup_commit_reference(the_repository, &remote_oid))) {
578                 die("Could not parse remote commit %s (%s)",
579                     oid_to_hex(&remote_oid), o->remote_ref);
580         }
581         trace_printf("\tremote commit: %.7s\n", oid_to_hex(&remote_oid));
582
583         if (!local && !remote)
584                 die("Cannot merge empty notes ref (%s) into empty notes ref "
585                     "(%s)", o->remote_ref, o->local_ref);
586         if (!local) {
587                 /* result == remote commit */
588                 oidcpy(result_oid, &remote_oid);
589                 goto found_result;
590         }
591         if (!remote) {
592                 /* result == local commit */
593                 oidcpy(result_oid, &local_oid);
594                 goto found_result;
595         }
596         assert(local && remote);
597
598         /* Find merge bases */
599         bases = get_merge_bases(local, remote);
600         if (!bases) {
601                 base_oid = &null_oid;
602                 base_tree_oid = the_hash_algo->empty_tree;
603                 if (o->verbosity >= 4)
604                         printf("No merge base found; doing history-less merge\n");
605         } else if (!bases->next) {
606                 base_oid = &bases->item->object.oid;
607                 base_tree_oid = get_commit_tree_oid(bases->item);
608                 if (o->verbosity >= 4)
609                         printf("One merge base found (%.7s)\n",
610                                oid_to_hex(base_oid));
611         } else {
612                 /* TODO: How to handle multiple merge-bases? */
613                 base_oid = &bases->item->object.oid;
614                 base_tree_oid = get_commit_tree_oid(bases->item);
615                 if (o->verbosity >= 3)
616                         printf("Multiple merge bases found. Using the first "
617                                 "(%.7s)\n", oid_to_hex(base_oid));
618         }
619
620         if (o->verbosity >= 4)
621                 printf("Merging remote commit %.7s into local commit %.7s with "
622                         "merge-base %.7s\n", oid_to_hex(&remote->object.oid),
623                         oid_to_hex(&local->object.oid),
624                         oid_to_hex(base_oid));
625
626         if (oideq(&remote->object.oid, base_oid)) {
627                 /* Already merged; result == local commit */
628                 if (o->verbosity >= 2)
629                         printf("Already up to date!\n");
630                 oidcpy(result_oid, &local->object.oid);
631                 goto found_result;
632         }
633         if (oideq(&local->object.oid, base_oid)) {
634                 /* Fast-forward; result == remote commit */
635                 if (o->verbosity >= 2)
636                         printf("Fast-forward\n");
637                 oidcpy(result_oid, &remote->object.oid);
638                 goto found_result;
639         }
640
641         result = merge_from_diffs(o, base_tree_oid,
642                                   get_commit_tree_oid(local),
643                                   get_commit_tree_oid(remote), local_tree);
644
645         if (result != 0) { /* non-trivial merge (with or without conflicts) */
646                 /* Commit (partial) result */
647                 struct commit_list *parents = NULL;
648                 commit_list_insert(remote, &parents); /* LIFO order */
649                 commit_list_insert(local, &parents);
650                 create_notes_commit(local_tree, parents, o->commit_msg.buf,
651                                     o->commit_msg.len, result_oid);
652         }
653
654 found_result:
655         free_commit_list(bases);
656         strbuf_release(&(o->commit_msg));
657         trace_printf("notes_merge(): result = %i, result_oid = %.7s\n",
658                result, oid_to_hex(result_oid));
659         return result;
660 }
661
662 int notes_merge_commit(struct notes_merge_options *o,
663                        struct notes_tree *partial_tree,
664                        struct commit *partial_commit,
665                        struct object_id *result_oid)
666 {
667         /*
668          * Iterate through files in .git/NOTES_MERGE_WORKTREE and add all
669          * found notes to 'partial_tree'. Write the updated notes tree to
670          * the DB, and commit the resulting tree object while reusing the
671          * commit message and parents from 'partial_commit'.
672          * Finally store the new commit object OID into 'result_oid'.
673          */
674         DIR *dir;
675         struct dirent *e;
676         struct strbuf path = STRBUF_INIT;
677         const char *buffer = get_commit_buffer(partial_commit, NULL);
678         const char *msg = strstr(buffer, "\n\n");
679         int baselen;
680
681         git_path_buf(&path, NOTES_MERGE_WORKTREE);
682         if (o->verbosity >= 3)
683                 printf("Committing notes in notes merge worktree at %s\n",
684                         path.buf);
685
686         if (!msg || msg[2] == '\0')
687                 die("partial notes commit has empty message");
688         msg += 2;
689
690         dir = opendir(path.buf);
691         if (!dir)
692                 die_errno("could not open %s", path.buf);
693
694         strbuf_addch(&path, '/');
695         baselen = path.len;
696         while ((e = readdir(dir)) != NULL) {
697                 struct stat st;
698                 struct object_id obj_oid, blob_oid;
699
700                 if (is_dot_or_dotdot(e->d_name))
701                         continue;
702
703                 if (get_oid_hex(e->d_name, &obj_oid)) {
704                         if (o->verbosity >= 3)
705                                 printf("Skipping non-SHA1 entry '%s%s'\n",
706                                         path.buf, e->d_name);
707                         continue;
708                 }
709
710                 strbuf_addstr(&path, e->d_name);
711                 /* write file as blob, and add to partial_tree */
712                 if (stat(path.buf, &st))
713                         die_errno("Failed to stat '%s'", path.buf);
714                 if (index_path(&the_index, &blob_oid, path.buf, &st, HASH_WRITE_OBJECT))
715                         die("Failed to write blob object from '%s'", path.buf);
716                 if (add_note(partial_tree, &obj_oid, &blob_oid, NULL))
717                         die("Failed to add resolved note '%s' to notes tree",
718                             path.buf);
719                 if (o->verbosity >= 4)
720                         printf("Added resolved note for object %s: %s\n",
721                                 oid_to_hex(&obj_oid), oid_to_hex(&blob_oid));
722                 strbuf_setlen(&path, baselen);
723         }
724
725         create_notes_commit(partial_tree, partial_commit->parents, msg,
726                             strlen(msg), result_oid);
727         unuse_commit_buffer(partial_commit, buffer);
728         if (o->verbosity >= 4)
729                 printf("Finalized notes merge commit: %s\n",
730                         oid_to_hex(result_oid));
731         strbuf_release(&path);
732         closedir(dir);
733         return 0;
734 }
735
736 int notes_merge_abort(struct notes_merge_options *o)
737 {
738         /*
739          * Remove all files within .git/NOTES_MERGE_WORKTREE. We do not remove
740          * the .git/NOTES_MERGE_WORKTREE directory itself, since it might be
741          * the current working directory of the user.
742          */
743         struct strbuf buf = STRBUF_INIT;
744         int ret;
745
746         git_path_buf(&buf, NOTES_MERGE_WORKTREE);
747         if (o->verbosity >= 3)
748                 printf("Removing notes merge worktree at %s/*\n", buf.buf);
749         ret = remove_dir_recursively(&buf, REMOVE_DIR_KEEP_TOPLEVEL);
750         strbuf_release(&buf);
751         return ret;
752 }