Merge branch 'jc/revision-range-unpeel'
[git] / builtin / notes.c
1 /*
2  * Builtin "git notes"
3  *
4  * Copyright (c) 2010 Johan Herland <johan@herland.net>
5  *
6  * Based on git-notes.sh by Johannes Schindelin,
7  * and builtin/tag.c by Kristian Høgsberg and Carlos Rica.
8  */
9
10 #include "cache.h"
11 #include "builtin.h"
12 #include "notes.h"
13 #include "blob.h"
14 #include "commit.h"
15 #include "refs.h"
16 #include "exec_cmd.h"
17 #include "run-command.h"
18 #include "parse-options.h"
19 #include "string-list.h"
20 #include "notes-merge.h"
21 #include "notes-utils.h"
22
23 static const char * const git_notes_usage[] = {
24         N_("git notes [--ref <notes_ref>] [list [<object>]]"),
25         N_("git notes [--ref <notes_ref>] add [-f] [-m <msg> | -F <file> | (-c | -C) <object>] [<object>]"),
26         N_("git notes [--ref <notes_ref>] copy [-f] <from-object> <to-object>"),
27         N_("git notes [--ref <notes_ref>] append [-m <msg> | -F <file> | (-c | -C) <object>] [<object>]"),
28         N_("git notes [--ref <notes_ref>] edit [<object>]"),
29         N_("git notes [--ref <notes_ref>] show [<object>]"),
30         N_("git notes [--ref <notes_ref>] merge [-v | -q] [-s <strategy> ] <notes_ref>"),
31         N_("git notes merge --commit [-v | -q]"),
32         N_("git notes merge --abort [-v | -q]"),
33         N_("git notes [--ref <notes_ref>] remove [<object>...]"),
34         N_("git notes [--ref <notes_ref>] prune [-n | -v]"),
35         N_("git notes [--ref <notes_ref>] get-ref"),
36         NULL
37 };
38
39 static const char * const git_notes_list_usage[] = {
40         N_("git notes [list [<object>]]"),
41         NULL
42 };
43
44 static const char * const git_notes_add_usage[] = {
45         N_("git notes add [<options>] [<object>]"),
46         NULL
47 };
48
49 static const char * const git_notes_copy_usage[] = {
50         N_("git notes copy [<options>] <from-object> <to-object>"),
51         N_("git notes copy --stdin [<from-object> <to-object>]..."),
52         NULL
53 };
54
55 static const char * const git_notes_append_usage[] = {
56         N_("git notes append [<options>] [<object>]"),
57         NULL
58 };
59
60 static const char * const git_notes_edit_usage[] = {
61         N_("git notes edit [<object>]"),
62         NULL
63 };
64
65 static const char * const git_notes_show_usage[] = {
66         N_("git notes show [<object>]"),
67         NULL
68 };
69
70 static const char * const git_notes_merge_usage[] = {
71         N_("git notes merge [<options>] <notes_ref>"),
72         N_("git notes merge --commit [<options>]"),
73         N_("git notes merge --abort [<options>]"),
74         NULL
75 };
76
77 static const char * const git_notes_remove_usage[] = {
78         N_("git notes remove [<object>]"),
79         NULL
80 };
81
82 static const char * const git_notes_prune_usage[] = {
83         N_("git notes prune [<options>]"),
84         NULL
85 };
86
87 static const char * const git_notes_get_ref_usage[] = {
88         N_("git notes get-ref"),
89         NULL
90 };
91
92 static const char note_template[] =
93         "\nWrite/edit the notes for the following object:\n";
94
95 struct msg_arg {
96         int given;
97         int use_editor;
98         struct strbuf buf;
99 };
100
101 static int list_each_note(const unsigned char *object_sha1,
102                 const unsigned char *note_sha1, char *note_path,
103                 void *cb_data)
104 {
105         printf("%s %s\n", sha1_to_hex(note_sha1), sha1_to_hex(object_sha1));
106         return 0;
107 }
108
109 static void write_note_data(int fd, const unsigned char *sha1)
110 {
111         unsigned long size;
112         enum object_type type;
113         char *buf = read_sha1_file(sha1, &type, &size);
114         if (buf) {
115                 if (size)
116                         write_or_die(fd, buf, size);
117                 free(buf);
118         }
119 }
120
121 static void write_commented_object(int fd, const unsigned char *object)
122 {
123         const char *show_args[5] =
124                 {"show", "--stat", "--no-notes", sha1_to_hex(object), NULL};
125         struct child_process show;
126         struct strbuf buf = STRBUF_INIT;
127         struct strbuf cbuf = STRBUF_INIT;
128
129         /* Invoke "git show --stat --no-notes $object" */
130         memset(&show, 0, sizeof(show));
131         show.argv = show_args;
132         show.no_stdin = 1;
133         show.out = -1;
134         show.err = 0;
135         show.git_cmd = 1;
136         if (start_command(&show))
137                 die(_("unable to start 'show' for object '%s'"),
138                     sha1_to_hex(object));
139
140         if (strbuf_read(&buf, show.out, 0) < 0)
141                 die_errno(_("could not read 'show' output"));
142         strbuf_add_commented_lines(&cbuf, buf.buf, buf.len);
143         write_or_die(fd, cbuf.buf, cbuf.len);
144
145         strbuf_release(&cbuf);
146         strbuf_release(&buf);
147
148         if (finish_command(&show))
149                 die(_("failed to finish 'show' for object '%s'"),
150                     sha1_to_hex(object));
151 }
152
153 static void create_note(const unsigned char *object, struct msg_arg *msg,
154                         int append_only, const unsigned char *prev,
155                         unsigned char *result)
156 {
157         char *path = NULL;
158
159         if (msg->use_editor || !msg->given) {
160                 int fd;
161                 struct strbuf buf = STRBUF_INIT;
162
163                 /* write the template message before editing: */
164                 path = git_pathdup("NOTES_EDITMSG");
165                 fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0600);
166                 if (fd < 0)
167                         die_errno(_("could not create file '%s'"), path);
168
169                 if (msg->given)
170                         write_or_die(fd, msg->buf.buf, msg->buf.len);
171                 else if (prev && !append_only)
172                         write_note_data(fd, prev);
173
174                 strbuf_addch(&buf, '\n');
175                 strbuf_add_commented_lines(&buf, note_template, strlen(note_template));
176                 strbuf_addch(&buf, '\n');
177                 write_or_die(fd, buf.buf, buf.len);
178
179                 write_commented_object(fd, object);
180
181                 close(fd);
182                 strbuf_release(&buf);
183                 strbuf_reset(&(msg->buf));
184
185                 if (launch_editor(path, &(msg->buf), NULL)) {
186                         die(_("Please supply the note contents using either -m" \
187                             " or -F option"));
188                 }
189                 stripspace(&(msg->buf), 1);
190         }
191
192         if (prev && append_only) {
193                 /* Append buf to previous note contents */
194                 unsigned long size;
195                 enum object_type type;
196                 char *prev_buf = read_sha1_file(prev, &type, &size);
197
198                 strbuf_grow(&(msg->buf), size + 1);
199                 if (msg->buf.len && prev_buf && size)
200                         strbuf_insert(&(msg->buf), 0, "\n", 1);
201                 if (prev_buf && size)
202                         strbuf_insert(&(msg->buf), 0, prev_buf, size);
203                 free(prev_buf);
204         }
205
206         if (!msg->buf.len) {
207                 fprintf(stderr, _("Removing note for object %s\n"),
208                         sha1_to_hex(object));
209                 hashclr(result);
210         } else {
211                 if (write_sha1_file(msg->buf.buf, msg->buf.len, blob_type, result)) {
212                         error(_("unable to write note object"));
213                         if (path)
214                                 error(_("The note contents has been left in %s"),
215                                       path);
216                         exit(128);
217                 }
218         }
219
220         if (path) {
221                 unlink_or_warn(path);
222                 free(path);
223         }
224 }
225
226 static int parse_msg_arg(const struct option *opt, const char *arg, int unset)
227 {
228         struct msg_arg *msg = opt->value;
229
230         strbuf_grow(&(msg->buf), strlen(arg) + 2);
231         if (msg->buf.len)
232                 strbuf_addch(&(msg->buf), '\n');
233         strbuf_addstr(&(msg->buf), arg);
234         stripspace(&(msg->buf), 0);
235
236         msg->given = 1;
237         return 0;
238 }
239
240 static int parse_file_arg(const struct option *opt, const char *arg, int unset)
241 {
242         struct msg_arg *msg = opt->value;
243
244         if (msg->buf.len)
245                 strbuf_addch(&(msg->buf), '\n');
246         if (!strcmp(arg, "-")) {
247                 if (strbuf_read(&(msg->buf), 0, 1024) < 0)
248                         die_errno(_("cannot read '%s'"), arg);
249         } else if (strbuf_read_file(&(msg->buf), arg, 1024) < 0)
250                 die_errno(_("could not open or read '%s'"), arg);
251         stripspace(&(msg->buf), 0);
252
253         msg->given = 1;
254         return 0;
255 }
256
257 static int parse_reuse_arg(const struct option *opt, const char *arg, int unset)
258 {
259         struct msg_arg *msg = opt->value;
260         char *buf;
261         unsigned char object[20];
262         enum object_type type;
263         unsigned long len;
264
265         if (msg->buf.len)
266                 strbuf_addch(&(msg->buf), '\n');
267
268         if (get_sha1(arg, object))
269                 die(_("Failed to resolve '%s' as a valid ref."), arg);
270         if (!(buf = read_sha1_file(object, &type, &len)) || !len) {
271                 free(buf);
272                 die(_("Failed to read object '%s'."), arg);;
273         }
274         strbuf_add(&(msg->buf), buf, len);
275         free(buf);
276
277         msg->given = 1;
278         return 0;
279 }
280
281 static int parse_reedit_arg(const struct option *opt, const char *arg, int unset)
282 {
283         struct msg_arg *msg = opt->value;
284         msg->use_editor = 1;
285         return parse_reuse_arg(opt, arg, unset);
286 }
287
288 static int notes_copy_from_stdin(int force, const char *rewrite_cmd)
289 {
290         struct strbuf buf = STRBUF_INIT;
291         struct notes_rewrite_cfg *c = NULL;
292         struct notes_tree *t = NULL;
293         int ret = 0;
294         const char *msg = "Notes added by 'git notes copy'";
295
296         if (rewrite_cmd) {
297                 c = init_copy_notes_for_rewrite(rewrite_cmd);
298                 if (!c)
299                         return 0;
300         } else {
301                 init_notes(NULL, NULL, NULL, 0);
302                 t = &default_notes_tree;
303         }
304
305         while (strbuf_getline(&buf, stdin, '\n') != EOF) {
306                 unsigned char from_obj[20], to_obj[20];
307                 struct strbuf **split;
308                 int err;
309
310                 split = strbuf_split(&buf, ' ');
311                 if (!split[0] || !split[1])
312                         die(_("Malformed input line: '%s'."), buf.buf);
313                 strbuf_rtrim(split[0]);
314                 strbuf_rtrim(split[1]);
315                 if (get_sha1(split[0]->buf, from_obj))
316                         die(_("Failed to resolve '%s' as a valid ref."), split[0]->buf);
317                 if (get_sha1(split[1]->buf, to_obj))
318                         die(_("Failed to resolve '%s' as a valid ref."), split[1]->buf);
319
320                 if (rewrite_cmd)
321                         err = copy_note_for_rewrite(c, from_obj, to_obj);
322                 else
323                         err = copy_note(t, from_obj, to_obj, force,
324                                         combine_notes_overwrite);
325
326                 if (err) {
327                         error(_("Failed to copy notes from '%s' to '%s'"),
328                               split[0]->buf, split[1]->buf);
329                         ret = 1;
330                 }
331
332                 strbuf_list_free(split);
333         }
334
335         if (!rewrite_cmd) {
336                 commit_notes(t, msg);
337                 free_notes(t);
338         } else {
339                 finish_copy_notes_for_rewrite(c, msg);
340         }
341         return ret;
342 }
343
344 static struct notes_tree *init_notes_check(const char *subcommand)
345 {
346         struct notes_tree *t;
347         init_notes(NULL, NULL, NULL, 0);
348         t = &default_notes_tree;
349
350         if (prefixcmp(t->ref, "refs/notes/"))
351                 die("Refusing to %s notes in %s (outside of refs/notes/)",
352                     subcommand, t->ref);
353         return t;
354 }
355
356 static int list(int argc, const char **argv, const char *prefix)
357 {
358         struct notes_tree *t;
359         unsigned char object[20];
360         const unsigned char *note;
361         int retval = -1;
362         struct option options[] = {
363                 OPT_END()
364         };
365
366         if (argc)
367                 argc = parse_options(argc, argv, prefix, options,
368                                      git_notes_list_usage, 0);
369
370         if (1 < argc) {
371                 error(_("too many parameters"));
372                 usage_with_options(git_notes_list_usage, options);
373         }
374
375         t = init_notes_check("list");
376         if (argc) {
377                 if (get_sha1(argv[0], object))
378                         die(_("Failed to resolve '%s' as a valid ref."), argv[0]);
379                 note = get_note(t, object);
380                 if (note) {
381                         puts(sha1_to_hex(note));
382                         retval = 0;
383                 } else
384                         retval = error(_("No note found for object %s."),
385                                        sha1_to_hex(object));
386         } else
387                 retval = for_each_note(t, 0, list_each_note, NULL);
388
389         free_notes(t);
390         return retval;
391 }
392
393 static int append_edit(int argc, const char **argv, const char *prefix);
394
395 static int add(int argc, const char **argv, const char *prefix)
396 {
397         int retval = 0, force = 0;
398         const char *object_ref;
399         struct notes_tree *t;
400         unsigned char object[20], new_note[20];
401         char logmsg[100];
402         const unsigned char *note;
403         struct msg_arg msg = { 0, 0, STRBUF_INIT };
404         struct option options[] = {
405                 { OPTION_CALLBACK, 'm', "message", &msg, N_("message"),
406                         N_("note contents as a string"), PARSE_OPT_NONEG,
407                         parse_msg_arg},
408                 { OPTION_CALLBACK, 'F', "file", &msg, N_("file"),
409                         N_("note contents in a file"), PARSE_OPT_NONEG,
410                         parse_file_arg},
411                 { OPTION_CALLBACK, 'c', "reedit-message", &msg, N_("object"),
412                         N_("reuse and edit specified note object"), PARSE_OPT_NONEG,
413                         parse_reedit_arg},
414                 { OPTION_CALLBACK, 'C', "reuse-message", &msg, N_("object"),
415                         N_("reuse specified note object"), PARSE_OPT_NONEG,
416                         parse_reuse_arg},
417                 OPT__FORCE(&force, N_("replace existing notes")),
418                 OPT_END()
419         };
420
421         argc = parse_options(argc, argv, prefix, options, git_notes_add_usage,
422                              PARSE_OPT_KEEP_ARGV0);
423
424         if (2 < argc) {
425                 error(_("too many parameters"));
426                 usage_with_options(git_notes_add_usage, options);
427         }
428
429         object_ref = argc > 1 ? argv[1] : "HEAD";
430
431         if (get_sha1(object_ref, object))
432                 die(_("Failed to resolve '%s' as a valid ref."), object_ref);
433
434         t = init_notes_check("add");
435         note = get_note(t, object);
436
437         if (note) {
438                 if (!force) {
439                         if (!msg.given) {
440                                 /*
441                                  * Redirect to "edit" subcommand.
442                                  *
443                                  * We only end up here if none of -m/-F/-c/-C
444                                  * or -f are given. The original args are
445                                  * therefore still in argv[0-1].
446                                  */
447                                 argv[0] = "edit";
448                                 free_notes(t);
449                                 return append_edit(argc, argv, prefix);
450                         }
451                         retval = error(_("Cannot add notes. Found existing notes "
452                                        "for object %s. Use '-f' to overwrite "
453                                        "existing notes"), sha1_to_hex(object));
454                         goto out;
455                 }
456                 fprintf(stderr, _("Overwriting existing notes for object %s\n"),
457                         sha1_to_hex(object));
458         }
459
460         create_note(object, &msg, 0, note, new_note);
461
462         if (is_null_sha1(new_note))
463                 remove_note(t, object);
464         else if (add_note(t, object, new_note, combine_notes_overwrite))
465                 die("BUG: combine_notes_overwrite failed");
466
467         snprintf(logmsg, sizeof(logmsg), "Notes %s by 'git notes %s'",
468                  is_null_sha1(new_note) ? "removed" : "added", "add");
469         commit_notes(t, logmsg);
470 out:
471         free_notes(t);
472         strbuf_release(&(msg.buf));
473         return retval;
474 }
475
476 static int copy(int argc, const char **argv, const char *prefix)
477 {
478         int retval = 0, force = 0, from_stdin = 0;
479         const unsigned char *from_note, *note;
480         const char *object_ref;
481         unsigned char object[20], from_obj[20];
482         struct notes_tree *t;
483         const char *rewrite_cmd = NULL;
484         struct option options[] = {
485                 OPT__FORCE(&force, N_("replace existing notes")),
486                 OPT_BOOL(0, "stdin", &from_stdin, N_("read objects from stdin")),
487                 OPT_STRING(0, "for-rewrite", &rewrite_cmd, N_("command"),
488                            N_("load rewriting config for <command> (implies "
489                               "--stdin)")),
490                 OPT_END()
491         };
492
493         argc = parse_options(argc, argv, prefix, options, git_notes_copy_usage,
494                              0);
495
496         if (from_stdin || rewrite_cmd) {
497                 if (argc) {
498                         error(_("too many parameters"));
499                         usage_with_options(git_notes_copy_usage, options);
500                 } else {
501                         return notes_copy_from_stdin(force, rewrite_cmd);
502                 }
503         }
504
505         if (argc < 2) {
506                 error(_("too few parameters"));
507                 usage_with_options(git_notes_copy_usage, options);
508         }
509         if (2 < argc) {
510                 error(_("too many parameters"));
511                 usage_with_options(git_notes_copy_usage, options);
512         }
513
514         if (get_sha1(argv[0], from_obj))
515                 die(_("Failed to resolve '%s' as a valid ref."), argv[0]);
516
517         object_ref = 1 < argc ? argv[1] : "HEAD";
518
519         if (get_sha1(object_ref, object))
520                 die(_("Failed to resolve '%s' as a valid ref."), object_ref);
521
522         t = init_notes_check("copy");
523         note = get_note(t, object);
524
525         if (note) {
526                 if (!force) {
527                         retval = error(_("Cannot copy notes. Found existing "
528                                        "notes for object %s. Use '-f' to "
529                                        "overwrite existing notes"),
530                                        sha1_to_hex(object));
531                         goto out;
532                 }
533                 fprintf(stderr, _("Overwriting existing notes for object %s\n"),
534                         sha1_to_hex(object));
535         }
536
537         from_note = get_note(t, from_obj);
538         if (!from_note) {
539                 retval = error(_("Missing notes on source object %s. Cannot "
540                                "copy."), sha1_to_hex(from_obj));
541                 goto out;
542         }
543
544         if (add_note(t, object, from_note, combine_notes_overwrite))
545                 die("BUG: combine_notes_overwrite failed");
546         commit_notes(t, "Notes added by 'git notes copy'");
547 out:
548         free_notes(t);
549         return retval;
550 }
551
552 static int append_edit(int argc, const char **argv, const char *prefix)
553 {
554         const char *object_ref;
555         struct notes_tree *t;
556         unsigned char object[20], new_note[20];
557         const unsigned char *note;
558         char logmsg[100];
559         const char * const *usage;
560         struct msg_arg msg = { 0, 0, STRBUF_INIT };
561         struct option options[] = {
562                 { OPTION_CALLBACK, 'm', "message", &msg, N_("message"),
563                         N_("note contents as a string"), PARSE_OPT_NONEG,
564                         parse_msg_arg},
565                 { OPTION_CALLBACK, 'F', "file", &msg, N_("file"),
566                         N_("note contents in a file"), PARSE_OPT_NONEG,
567                         parse_file_arg},
568                 { OPTION_CALLBACK, 'c', "reedit-message", &msg, N_("object"),
569                         N_("reuse and edit specified note object"), PARSE_OPT_NONEG,
570                         parse_reedit_arg},
571                 { OPTION_CALLBACK, 'C', "reuse-message", &msg, N_("object"),
572                         N_("reuse specified note object"), PARSE_OPT_NONEG,
573                         parse_reuse_arg},
574                 OPT_END()
575         };
576         int edit = !strcmp(argv[0], "edit");
577
578         usage = edit ? git_notes_edit_usage : git_notes_append_usage;
579         argc = parse_options(argc, argv, prefix, options, usage,
580                              PARSE_OPT_KEEP_ARGV0);
581
582         if (2 < argc) {
583                 error(_("too many parameters"));
584                 usage_with_options(usage, options);
585         }
586
587         if (msg.given && edit)
588                 fprintf(stderr, _("The -m/-F/-c/-C options have been deprecated "
589                         "for the 'edit' subcommand.\n"
590                         "Please use 'git notes add -f -m/-F/-c/-C' instead.\n"));
591
592         object_ref = 1 < argc ? argv[1] : "HEAD";
593
594         if (get_sha1(object_ref, object))
595                 die(_("Failed to resolve '%s' as a valid ref."), object_ref);
596
597         t = init_notes_check(argv[0]);
598         note = get_note(t, object);
599
600         create_note(object, &msg, !edit, note, new_note);
601
602         if (is_null_sha1(new_note))
603                 remove_note(t, object);
604         else if (add_note(t, object, new_note, combine_notes_overwrite))
605                 die("BUG: combine_notes_overwrite failed");
606
607         snprintf(logmsg, sizeof(logmsg), "Notes %s by 'git notes %s'",
608                  is_null_sha1(new_note) ? "removed" : "added", argv[0]);
609         commit_notes(t, logmsg);
610         free_notes(t);
611         strbuf_release(&(msg.buf));
612         return 0;
613 }
614
615 static int show(int argc, const char **argv, const char *prefix)
616 {
617         const char *object_ref;
618         struct notes_tree *t;
619         unsigned char object[20];
620         const unsigned char *note;
621         int retval;
622         struct option options[] = {
623                 OPT_END()
624         };
625
626         argc = parse_options(argc, argv, prefix, options, git_notes_show_usage,
627                              0);
628
629         if (1 < argc) {
630                 error(_("too many parameters"));
631                 usage_with_options(git_notes_show_usage, options);
632         }
633
634         object_ref = argc ? argv[0] : "HEAD";
635
636         if (get_sha1(object_ref, object))
637                 die(_("Failed to resolve '%s' as a valid ref."), object_ref);
638
639         t = init_notes_check("show");
640         note = get_note(t, object);
641
642         if (!note)
643                 retval = error(_("No note found for object %s."),
644                                sha1_to_hex(object));
645         else {
646                 const char *show_args[3] = {"show", sha1_to_hex(note), NULL};
647                 retval = execv_git_cmd(show_args);
648         }
649         free_notes(t);
650         return retval;
651 }
652
653 static int merge_abort(struct notes_merge_options *o)
654 {
655         int ret = 0;
656
657         /*
658          * Remove .git/NOTES_MERGE_PARTIAL and .git/NOTES_MERGE_REF, and call
659          * notes_merge_abort() to remove .git/NOTES_MERGE_WORKTREE.
660          */
661
662         if (delete_ref("NOTES_MERGE_PARTIAL", NULL, 0))
663                 ret += error("Failed to delete ref NOTES_MERGE_PARTIAL");
664         if (delete_ref("NOTES_MERGE_REF", NULL, REF_NODEREF))
665                 ret += error("Failed to delete ref NOTES_MERGE_REF");
666         if (notes_merge_abort(o))
667                 ret += error("Failed to remove 'git notes merge' worktree");
668         return ret;
669 }
670
671 static int merge_commit(struct notes_merge_options *o)
672 {
673         struct strbuf msg = STRBUF_INIT;
674         unsigned char sha1[20], parent_sha1[20];
675         struct notes_tree *t;
676         struct commit *partial;
677         struct pretty_print_context pretty_ctx;
678         void *local_ref_to_free;
679         int ret;
680
681         /*
682          * Read partial merge result from .git/NOTES_MERGE_PARTIAL,
683          * and target notes ref from .git/NOTES_MERGE_REF.
684          */
685
686         if (get_sha1("NOTES_MERGE_PARTIAL", sha1))
687                 die("Failed to read ref NOTES_MERGE_PARTIAL");
688         else if (!(partial = lookup_commit_reference(sha1)))
689                 die("Could not find commit from NOTES_MERGE_PARTIAL.");
690         else if (parse_commit(partial))
691                 die("Could not parse commit from NOTES_MERGE_PARTIAL.");
692
693         if (partial->parents)
694                 hashcpy(parent_sha1, partial->parents->item->object.sha1);
695         else
696                 hashclr(parent_sha1);
697
698         t = xcalloc(1, sizeof(struct notes_tree));
699         init_notes(t, "NOTES_MERGE_PARTIAL", combine_notes_overwrite, 0);
700
701         o->local_ref = local_ref_to_free =
702                 resolve_refdup("NOTES_MERGE_REF", sha1, 0, NULL);
703         if (!o->local_ref)
704                 die("Failed to resolve NOTES_MERGE_REF");
705
706         if (notes_merge_commit(o, t, partial, sha1))
707                 die("Failed to finalize notes merge");
708
709         /* Reuse existing commit message in reflog message */
710         memset(&pretty_ctx, 0, sizeof(pretty_ctx));
711         format_commit_message(partial, "%s", &msg, &pretty_ctx);
712         strbuf_trim(&msg);
713         strbuf_insert(&msg, 0, "notes: ", 7);
714         update_ref(msg.buf, o->local_ref, sha1,
715                    is_null_sha1(parent_sha1) ? NULL : parent_sha1,
716                    0, DIE_ON_ERR);
717
718         free_notes(t);
719         strbuf_release(&msg);
720         ret = merge_abort(o);
721         free(local_ref_to_free);
722         return ret;
723 }
724
725 static int merge(int argc, const char **argv, const char *prefix)
726 {
727         struct strbuf remote_ref = STRBUF_INIT, msg = STRBUF_INIT;
728         unsigned char result_sha1[20];
729         struct notes_tree *t;
730         struct notes_merge_options o;
731         int do_merge = 0, do_commit = 0, do_abort = 0;
732         int verbosity = 0, result;
733         const char *strategy = NULL;
734         struct option options[] = {
735                 OPT_GROUP(N_("General options")),
736                 OPT__VERBOSITY(&verbosity),
737                 OPT_GROUP(N_("Merge options")),
738                 OPT_STRING('s', "strategy", &strategy, N_("strategy"),
739                            N_("resolve notes conflicts using the given strategy "
740                               "(manual/ours/theirs/union/cat_sort_uniq)")),
741                 OPT_GROUP(N_("Committing unmerged notes")),
742                 { OPTION_SET_INT, 0, "commit", &do_commit, NULL,
743                         N_("finalize notes merge by committing unmerged notes"),
744                         PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, 1},
745                 OPT_GROUP(N_("Aborting notes merge resolution")),
746                 { OPTION_SET_INT, 0, "abort", &do_abort, NULL,
747                         N_("abort notes merge"),
748                         PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, 1},
749                 OPT_END()
750         };
751
752         argc = parse_options(argc, argv, prefix, options,
753                              git_notes_merge_usage, 0);
754
755         if (strategy || do_commit + do_abort == 0)
756                 do_merge = 1;
757         if (do_merge + do_commit + do_abort != 1) {
758                 error("cannot mix --commit, --abort or -s/--strategy");
759                 usage_with_options(git_notes_merge_usage, options);
760         }
761
762         if (do_merge && argc != 1) {
763                 error("Must specify a notes ref to merge");
764                 usage_with_options(git_notes_merge_usage, options);
765         } else if (!do_merge && argc) {
766                 error("too many parameters");
767                 usage_with_options(git_notes_merge_usage, options);
768         }
769
770         init_notes_merge_options(&o);
771         o.verbosity = verbosity + NOTES_MERGE_VERBOSITY_DEFAULT;
772
773         if (do_abort)
774                 return merge_abort(&o);
775         if (do_commit)
776                 return merge_commit(&o);
777
778         o.local_ref = default_notes_ref();
779         strbuf_addstr(&remote_ref, argv[0]);
780         expand_notes_ref(&remote_ref);
781         o.remote_ref = remote_ref.buf;
782
783         if (strategy) {
784                 if (!strcmp(strategy, "manual"))
785                         o.strategy = NOTES_MERGE_RESOLVE_MANUAL;
786                 else if (!strcmp(strategy, "ours"))
787                         o.strategy = NOTES_MERGE_RESOLVE_OURS;
788                 else if (!strcmp(strategy, "theirs"))
789                         o.strategy = NOTES_MERGE_RESOLVE_THEIRS;
790                 else if (!strcmp(strategy, "union"))
791                         o.strategy = NOTES_MERGE_RESOLVE_UNION;
792                 else if (!strcmp(strategy, "cat_sort_uniq"))
793                         o.strategy = NOTES_MERGE_RESOLVE_CAT_SORT_UNIQ;
794                 else {
795                         error("Unknown -s/--strategy: %s", strategy);
796                         usage_with_options(git_notes_merge_usage, options);
797                 }
798         }
799
800         t = init_notes_check("merge");
801
802         strbuf_addf(&msg, "notes: Merged notes from %s into %s",
803                     remote_ref.buf, default_notes_ref());
804         strbuf_add(&(o.commit_msg), msg.buf + 7, msg.len - 7); /* skip "notes: " */
805
806         result = notes_merge(&o, t, result_sha1);
807
808         if (result >= 0) /* Merge resulted (trivially) in result_sha1 */
809                 /* Update default notes ref with new commit */
810                 update_ref(msg.buf, default_notes_ref(), result_sha1, NULL,
811                            0, DIE_ON_ERR);
812         else { /* Merge has unresolved conflicts */
813                 /* Update .git/NOTES_MERGE_PARTIAL with partial merge result */
814                 update_ref(msg.buf, "NOTES_MERGE_PARTIAL", result_sha1, NULL,
815                            0, DIE_ON_ERR);
816                 /* Store ref-to-be-updated into .git/NOTES_MERGE_REF */
817                 if (create_symref("NOTES_MERGE_REF", default_notes_ref(), NULL))
818                         die("Failed to store link to current notes ref (%s)",
819                             default_notes_ref());
820                 printf("Automatic notes merge failed. Fix conflicts in %s and "
821                        "commit the result with 'git notes merge --commit', or "
822                        "abort the merge with 'git notes merge --abort'.\n",
823                        git_path(NOTES_MERGE_WORKTREE));
824         }
825
826         free_notes(t);
827         strbuf_release(&remote_ref);
828         strbuf_release(&msg);
829         return result < 0; /* return non-zero on conflicts */
830 }
831
832 #define IGNORE_MISSING 1
833
834 static int remove_one_note(struct notes_tree *t, const char *name, unsigned flag)
835 {
836         int status;
837         unsigned char sha1[20];
838         if (get_sha1(name, sha1))
839                 return error(_("Failed to resolve '%s' as a valid ref."), name);
840         status = remove_note(t, sha1);
841         if (status)
842                 fprintf(stderr, _("Object %s has no note\n"), name);
843         else
844                 fprintf(stderr, _("Removing note for object %s\n"), name);
845         return (flag & IGNORE_MISSING) ? 0 : status;
846 }
847
848 static int remove_cmd(int argc, const char **argv, const char *prefix)
849 {
850         unsigned flag = 0;
851         int from_stdin = 0;
852         struct option options[] = {
853                 OPT_BIT(0, "ignore-missing", &flag,
854                         N_("attempt to remove non-existent note is not an error"),
855                         IGNORE_MISSING),
856                 OPT_BOOL(0, "stdin", &from_stdin,
857                             N_("read object names from the standard input")),
858                 OPT_END()
859         };
860         struct notes_tree *t;
861         int retval = 0;
862
863         argc = parse_options(argc, argv, prefix, options,
864                              git_notes_remove_usage, 0);
865
866         t = init_notes_check("remove");
867
868         if (!argc && !from_stdin) {
869                 retval = remove_one_note(t, "HEAD", flag);
870         } else {
871                 while (*argv) {
872                         retval |= remove_one_note(t, *argv, flag);
873                         argv++;
874                 }
875         }
876         if (from_stdin) {
877                 struct strbuf sb = STRBUF_INIT;
878                 while (strbuf_getwholeline(&sb, stdin, '\n') != EOF) {
879                         strbuf_rtrim(&sb);
880                         retval |= remove_one_note(t, sb.buf, flag);
881                 }
882                 strbuf_release(&sb);
883         }
884         if (!retval)
885                 commit_notes(t, "Notes removed by 'git notes remove'");
886         free_notes(t);
887         return retval;
888 }
889
890 static int prune(int argc, const char **argv, const char *prefix)
891 {
892         struct notes_tree *t;
893         int show_only = 0, verbose = 0;
894         struct option options[] = {
895                 OPT__DRY_RUN(&show_only, "do not remove, show only"),
896                 OPT__VERBOSE(&verbose, "report pruned notes"),
897                 OPT_END()
898         };
899
900         argc = parse_options(argc, argv, prefix, options, git_notes_prune_usage,
901                              0);
902
903         if (argc) {
904                 error(_("too many parameters"));
905                 usage_with_options(git_notes_prune_usage, options);
906         }
907
908         t = init_notes_check("prune");
909
910         prune_notes(t, (verbose ? NOTES_PRUNE_VERBOSE : 0) |
911                 (show_only ? NOTES_PRUNE_VERBOSE|NOTES_PRUNE_DRYRUN : 0) );
912         if (!show_only)
913                 commit_notes(t, "Notes removed by 'git notes prune'");
914         free_notes(t);
915         return 0;
916 }
917
918 static int get_ref(int argc, const char **argv, const char *prefix)
919 {
920         struct option options[] = { OPT_END() };
921         argc = parse_options(argc, argv, prefix, options,
922                              git_notes_get_ref_usage, 0);
923
924         if (argc) {
925                 error("too many parameters");
926                 usage_with_options(git_notes_get_ref_usage, options);
927         }
928
929         puts(default_notes_ref());
930         return 0;
931 }
932
933 int cmd_notes(int argc, const char **argv, const char *prefix)
934 {
935         int result;
936         const char *override_notes_ref = NULL;
937         struct option options[] = {
938                 OPT_STRING(0, "ref", &override_notes_ref, N_("notes_ref"),
939                            N_("use notes from <notes_ref>")),
940                 OPT_END()
941         };
942
943         git_config(git_default_config, NULL);
944         argc = parse_options(argc, argv, prefix, options, git_notes_usage,
945                              PARSE_OPT_STOP_AT_NON_OPTION);
946
947         if (override_notes_ref) {
948                 struct strbuf sb = STRBUF_INIT;
949                 strbuf_addstr(&sb, override_notes_ref);
950                 expand_notes_ref(&sb);
951                 setenv("GIT_NOTES_REF", sb.buf, 1);
952                 strbuf_release(&sb);
953         }
954
955         if (argc < 1 || !strcmp(argv[0], "list"))
956                 result = list(argc, argv, prefix);
957         else if (!strcmp(argv[0], "add"))
958                 result = add(argc, argv, prefix);
959         else if (!strcmp(argv[0], "copy"))
960                 result = copy(argc, argv, prefix);
961         else if (!strcmp(argv[0], "append") || !strcmp(argv[0], "edit"))
962                 result = append_edit(argc, argv, prefix);
963         else if (!strcmp(argv[0], "show"))
964                 result = show(argc, argv, prefix);
965         else if (!strcmp(argv[0], "merge"))
966                 result = merge(argc, argv, prefix);
967         else if (!strcmp(argv[0], "remove"))
968                 result = remove_cmd(argc, argv, prefix);
969         else if (!strcmp(argv[0], "prune"))
970                 result = prune(argc, argv, prefix);
971         else if (!strcmp(argv[0], "get-ref"))
972                 result = get_ref(argc, argv, prefix);
973         else {
974                 result = error(_("Unknown subcommand: %s"), argv[0]);
975                 usage_with_options(git_notes_usage, options);
976         }
977
978         return result ? 1 : 0;
979 }