4 * Copyright (c) 2010 Johan Herland <johan@herland.net>
6 * Based on git-notes.sh by Johannes Schindelin,
7 * and builtin/tag.c by Kristian Høgsberg and Carlos Rica.
9 #define USE_THE_REPOSITORY_VARIABLE
13 #include "environment.h"
17 #include "object-file.h"
18 #include "object-name.h"
19 #include "object-store.h"
25 #include "run-command.h"
26 #include "parse-options.h"
27 #include "string-list.h"
28 #include "notes-merge.h"
29 #include "notes-utils.h"
31 #include "write-or-die.h"
33 static const char *separator
= "\n";
34 static const char * const git_notes_usage
[] = {
35 N_("git notes [--ref <notes-ref>] [list [<object>]]"),
36 N_("git notes [--ref <notes-ref>] add [-f] [--allow-empty] [--[no-]separator|--separator=<paragraph-break>] [--[no-]stripspace] [-m <msg> | -F <file> | (-c | -C) <object>] [<object>] [-e]"),
37 N_("git notes [--ref <notes-ref>] copy [-f] <from-object> <to-object>"),
38 N_("git notes [--ref <notes-ref>] append [--allow-empty] [--[no-]separator|--separator=<paragraph-break>] [--[no-]stripspace] [-m <msg> | -F <file> | (-c | -C) <object>] [<object>] [-e]"),
39 N_("git notes [--ref <notes-ref>] edit [--allow-empty] [<object>]"),
40 N_("git notes [--ref <notes-ref>] show [<object>]"),
41 N_("git notes [--ref <notes-ref>] merge [-v | -q] [-s <strategy>] <notes-ref>"),
42 "git notes merge --commit [-v | -q]",
43 "git notes merge --abort [-v | -q]",
44 N_("git notes [--ref <notes-ref>] remove [<object>...]"),
45 N_("git notes [--ref <notes-ref>] prune [-n] [-v]"),
46 N_("git notes [--ref <notes-ref>] get-ref"),
50 static const char * const git_notes_list_usage
[] = {
51 N_("git notes [list [<object>]]"),
55 static const char * const git_notes_add_usage
[] = {
56 N_("git notes add [<options>] [<object>]"),
60 static const char * const git_notes_copy_usage
[] = {
61 N_("git notes copy [<options>] <from-object> <to-object>"),
62 N_("git notes copy --stdin [<from-object> <to-object>]..."),
66 static const char * const git_notes_append_usage
[] = {
67 N_("git notes append [<options>] [<object>]"),
71 static const char * const git_notes_edit_usage
[] = {
72 N_("git notes edit [<object>]"),
76 static const char * const git_notes_show_usage
[] = {
77 N_("git notes show [<object>]"),
81 static const char * const git_notes_merge_usage
[] = {
82 N_("git notes merge [<options>] <notes-ref>"),
83 N_("git notes merge --commit [<options>]"),
84 N_("git notes merge --abort [<options>]"),
88 static const char * const git_notes_remove_usage
[] = {
89 N_("git notes remove [<object>]"),
93 static const char * const git_notes_prune_usage
[] = {
94 N_("git notes prune [<options>]"),
98 static const char * const git_notes_get_ref_usage
[] = {
103 static const char note_template
[] =
104 N_("Write/edit the notes for the following object:");
106 enum notes_stripspace
{
113 enum notes_stripspace stripspace
;
122 struct note_msg
**messages
;
127 static void free_note_data(struct note_data
*d
)
130 unlink_or_warn(d
->edit_path
);
133 strbuf_release(&d
->buf
);
135 while (d
->msg_nr
--) {
136 strbuf_release(&d
->messages
[d
->msg_nr
]->buf
);
137 free(d
->messages
[d
->msg_nr
]);
142 static int list_each_note(const struct object_id
*object_oid
,
143 const struct object_id
*note_oid
,
144 char *note_path UNUSED
,
145 void *cb_data UNUSED
)
147 printf("%s %s\n", oid_to_hex(note_oid
), oid_to_hex(object_oid
));
151 static void copy_obj_to_fd(int fd
, const struct object_id
*oid
)
154 enum object_type type
;
155 char *buf
= repo_read_object_file(the_repository
, oid
, &type
, &size
);
158 write_or_die(fd
, buf
, size
);
163 static void write_commented_object(int fd
, const struct object_id
*object
)
165 struct child_process show
= CHILD_PROCESS_INIT
;
166 struct strbuf buf
= STRBUF_INIT
;
167 struct strbuf cbuf
= STRBUF_INIT
;
169 /* Invoke "git show --stat --no-notes $object" */
170 strvec_pushl(&show
.args
, "show", "--stat", "--no-notes",
171 oid_to_hex(object
), NULL
);
176 if (start_command(&show
))
177 die(_("unable to start 'show' for object '%s'"),
180 if (strbuf_read(&buf
, show
.out
, 0) < 0)
181 die_errno(_("could not read 'show' output"));
182 strbuf_add_commented_lines(&cbuf
, buf
.buf
, buf
.len
, comment_line_str
);
183 write_or_die(fd
, cbuf
.buf
, cbuf
.len
);
185 strbuf_release(&cbuf
);
186 strbuf_release(&buf
);
188 if (finish_command(&show
))
189 die(_("failed to finish 'show' for object '%s'"),
193 static void prepare_note_data(const struct object_id
*object
, struct note_data
*d
,
194 const struct object_id
*old_note
)
196 if (d
->use_editor
|| !d
->msg_nr
) {
198 struct strbuf buf
= STRBUF_INIT
;
200 /* write the template message before editing: */
201 d
->edit_path
= repo_git_path(the_repository
, "NOTES_EDITMSG");
202 fd
= xopen(d
->edit_path
, O_CREAT
| O_TRUNC
| O_WRONLY
, 0600);
205 write_or_die(fd
, d
->buf
.buf
, d
->buf
.len
);
207 copy_obj_to_fd(fd
, old_note
);
209 strbuf_addch(&buf
, '\n');
210 strbuf_add_commented_lines(&buf
, "\n", strlen("\n"), comment_line_str
);
211 strbuf_add_commented_lines(&buf
, _(note_template
), strlen(_(note_template
)),
213 strbuf_add_commented_lines(&buf
, "\n", strlen("\n"), comment_line_str
);
214 write_or_die(fd
, buf
.buf
, buf
.len
);
216 write_commented_object(fd
, object
);
219 strbuf_release(&buf
);
220 strbuf_reset(&d
->buf
);
222 if (launch_editor(d
->edit_path
, &d
->buf
, NULL
)) {
223 die(_("please supply the note contents using either -m or -F option"));
226 strbuf_stripspace(&d
->buf
, comment_line_str
);
230 static void write_note_data(struct note_data
*d
, struct object_id
*oid
)
232 if (write_object_file(d
->buf
.buf
, d
->buf
.len
, OBJ_BLOB
, oid
)) {
233 int status
= die_message(_("unable to write note object"));
236 die_message(_("the note contents have been left in %s"),
242 static void append_separator(struct strbuf
*message
)
248 else if ((sep_len
= strlen(separator
)) && separator
[sep_len
- 1] == '\n')
249 strbuf_addstr(message
, separator
);
251 strbuf_addf(message
, "%s%s", separator
, "\n");
254 static void concat_messages(struct note_data
*d
)
256 struct strbuf msg
= STRBUF_INIT
;
259 for (i
= 0; i
< d
->msg_nr
; i
++) {
261 append_separator(&d
->buf
);
262 strbuf_add(&msg
, d
->messages
[i
]->buf
.buf
, d
->messages
[i
]->buf
.len
);
263 strbuf_addbuf(&d
->buf
, &msg
);
264 if ((d
->stripspace
== UNSPECIFIED
&&
265 d
->messages
[i
]->stripspace
== STRIPSPACE
) ||
266 d
->stripspace
== STRIPSPACE
)
267 strbuf_stripspace(&d
->buf
, NULL
);
270 strbuf_release(&msg
);
273 static int parse_msg_arg(const struct option
*opt
, const char *arg
, int unset
)
275 struct note_data
*d
= opt
->value
;
276 struct note_msg
*msg
= xmalloc(sizeof(*msg
));
278 BUG_ON_OPT_NEG(unset
);
280 strbuf_init(&msg
->buf
, strlen(arg
));
281 strbuf_addstr(&msg
->buf
, arg
);
282 ALLOC_GROW_BY(d
->messages
, d
->msg_nr
, 1, d
->msg_alloc
);
283 d
->messages
[d
->msg_nr
- 1] = msg
;
284 msg
->stripspace
= STRIPSPACE
;
288 static int parse_file_arg(const struct option
*opt
, const char *arg
, int unset
)
290 struct note_data
*d
= opt
->value
;
291 struct note_msg
*msg
= xmalloc(sizeof(*msg
));
293 BUG_ON_OPT_NEG(unset
);
295 strbuf_init(&msg
->buf
, 0);
296 if (!strcmp(arg
, "-")) {
297 if (strbuf_read(&msg
->buf
, 0, 1024) < 0)
298 die_errno(_("cannot read '%s'"), arg
);
299 } else if (strbuf_read_file(&msg
->buf
, arg
, 1024) < 0)
300 die_errno(_("could not open or read '%s'"), arg
);
302 ALLOC_GROW_BY(d
->messages
, d
->msg_nr
, 1, d
->msg_alloc
);
303 d
->messages
[d
->msg_nr
- 1] = msg
;
304 msg
->stripspace
= STRIPSPACE
;
308 static int parse_reuse_arg(const struct option
*opt
, const char *arg
, int unset
)
310 struct note_data
*d
= opt
->value
;
311 struct note_msg
*msg
= xmalloc(sizeof(*msg
));
313 struct object_id object
;
314 enum object_type type
;
317 BUG_ON_OPT_NEG(unset
);
319 strbuf_init(&msg
->buf
, 0);
320 if (repo_get_oid(the_repository
, arg
, &object
))
321 die(_("failed to resolve '%s' as a valid ref."), arg
);
322 if (!(value
= repo_read_object_file(the_repository
, &object
, &type
, &len
)))
323 die(_("failed to read object '%s'."), arg
);
324 if (type
!= OBJ_BLOB
) {
325 strbuf_release(&msg
->buf
);
328 die(_("cannot read note data from non-blob object '%s'."), arg
);
331 strbuf_add(&msg
->buf
, value
, len
);
335 ALLOC_GROW_BY(d
->messages
, d
->msg_nr
, 1, d
->msg_alloc
);
336 d
->messages
[d
->msg_nr
- 1] = msg
;
337 msg
->stripspace
= NO_STRIPSPACE
;
341 static int parse_reedit_arg(const struct option
*opt
, const char *arg
, int unset
)
343 struct note_data
*d
= opt
->value
;
344 BUG_ON_OPT_NEG(unset
);
346 return parse_reuse_arg(opt
, arg
, unset
);
349 static int parse_separator_arg(const struct option
*opt
, const char *arg
,
353 *(const char **)opt
->value
= NULL
;
355 *(const char **)opt
->value
= arg
? arg
: "\n";
359 static int notes_copy_from_stdin(int force
, const char *rewrite_cmd
)
361 struct strbuf buf
= STRBUF_INIT
;
362 struct notes_rewrite_cfg
*c
= NULL
;
363 struct notes_tree
*t
= NULL
;
365 const char *msg
= "Notes added by 'git notes copy'";
368 c
= init_copy_notes_for_rewrite(rewrite_cmd
);
372 init_notes(NULL
, NULL
, NULL
, NOTES_INIT_WRITABLE
);
373 t
= &default_notes_tree
;
376 while (strbuf_getline_lf(&buf
, stdin
) != EOF
) {
377 struct object_id from_obj
, to_obj
;
378 struct strbuf
**split
;
381 split
= strbuf_split(&buf
, ' ');
382 if (!split
[0] || !split
[1])
383 die(_("malformed input line: '%s'."), buf
.buf
);
384 strbuf_rtrim(split
[0]);
385 strbuf_rtrim(split
[1]);
386 if (repo_get_oid(the_repository
, split
[0]->buf
, &from_obj
))
387 die(_("failed to resolve '%s' as a valid ref."), split
[0]->buf
);
388 if (repo_get_oid(the_repository
, split
[1]->buf
, &to_obj
))
389 die(_("failed to resolve '%s' as a valid ref."), split
[1]->buf
);
392 err
= copy_note_for_rewrite(c
, &from_obj
, &to_obj
);
394 err
= copy_note(t
, &from_obj
, &to_obj
, force
,
395 combine_notes_overwrite
);
398 error(_("failed to copy notes from '%s' to '%s'"),
399 split
[0]->buf
, split
[1]->buf
);
403 strbuf_list_free(split
);
407 commit_notes(the_repository
, t
, msg
);
410 finish_copy_notes_for_rewrite(the_repository
, c
, msg
);
412 strbuf_release(&buf
);
416 static struct notes_tree
*init_notes_check(const char *subcommand
,
419 struct notes_tree
*t
;
421 init_notes(NULL
, NULL
, NULL
, flags
);
422 t
= &default_notes_tree
;
424 ref
= (flags
& NOTES_INIT_WRITABLE
) ? t
->update_ref
: t
->ref
;
425 if (!starts_with(ref
, "refs/notes/"))
427 * TRANSLATORS: the first %s will be replaced by a git
428 * notes command: 'add', 'merge', 'remove', etc.
430 die(_("refusing to %s notes in %s (outside of refs/notes/)"),
435 static int list(int argc
, const char **argv
, const char *prefix
,
436 struct repository
*repo UNUSED
)
438 struct notes_tree
*t
;
439 struct object_id object
;
440 const struct object_id
*note
;
442 struct option options
[] = {
447 argc
= parse_options(argc
, argv
, prefix
, options
,
448 git_notes_list_usage
, 0);
451 error(_("too many arguments"));
452 usage_with_options(git_notes_list_usage
, options
);
455 t
= init_notes_check("list", 0);
457 if (repo_get_oid(the_repository
, argv
[0], &object
))
458 die(_("failed to resolve '%s' as a valid ref."), argv
[0]);
459 note
= get_note(t
, &object
);
461 puts(oid_to_hex(note
));
464 retval
= error(_("no note found for object %s."),
465 oid_to_hex(&object
));
467 retval
= for_each_note(t
, 0, list_each_note
, NULL
);
473 static int append_edit(int argc
, const char **argv
, const char *prefix
,
474 struct repository
*repo UNUSED
);
476 static int add(int argc
, const char **argv
, const char *prefix
,
477 struct repository
*repo
)
479 int force
= 0, allow_empty
= 0;
480 const char *object_ref
;
481 struct notes_tree
*t
;
482 struct object_id object
, new_note
;
483 const struct object_id
*note
;
484 struct note_data d
= { .buf
= STRBUF_INIT
, .stripspace
= UNSPECIFIED
};
486 struct option options
[] = {
487 OPT_CALLBACK_F('m', "message", &d
, N_("message"),
488 N_("note contents as a string"), PARSE_OPT_NONEG
,
490 OPT_CALLBACK_F('F', "file", &d
, N_("file"),
491 N_("note contents in a file"), PARSE_OPT_NONEG
,
493 OPT_CALLBACK_F('c', "reedit-message", &d
, N_("object"),
494 N_("reuse and edit specified note object"), PARSE_OPT_NONEG
,
496 OPT_BOOL('e', "edit", &d
.use_editor
,
497 N_("edit note message in editor")),
498 OPT_CALLBACK_F('C', "reuse-message", &d
, N_("object"),
499 N_("reuse specified note object"), PARSE_OPT_NONEG
,
501 OPT_BOOL(0, "allow-empty", &allow_empty
,
502 N_("allow storing empty note")),
503 OPT__FORCE(&force
, N_("replace existing notes"), PARSE_OPT_NOCOMPLETE
),
504 OPT_CALLBACK_F(0, "separator", &separator
,
505 N_("<paragraph-break>"),
506 N_("insert <paragraph-break> between paragraphs"),
507 PARSE_OPT_OPTARG
, parse_separator_arg
),
508 OPT_BOOL(0, "stripspace", &d
.stripspace
,
509 N_("remove unnecessary whitespace")),
513 argc
= parse_options(argc
, argv
, prefix
, options
, git_notes_add_usage
,
514 PARSE_OPT_KEEP_ARGV0
);
517 error(_("too many arguments"));
518 usage_with_options(git_notes_add_usage
, options
);
524 object_ref
= argc
> 1 ? argv
[1] : "HEAD";
526 if (repo_get_oid(the_repository
, object_ref
, &object
))
527 die(_("failed to resolve '%s' as a valid ref."), object_ref
);
529 t
= init_notes_check("add", NOTES_INIT_WRITABLE
);
530 note
= get_note(t
, &object
);
537 return error(_("Cannot add notes. "
538 "Found existing notes for object %s. "
539 "Use '-f' to overwrite existing notes"),
540 oid_to_hex(&object
));
543 * Redirect to "edit" subcommand.
545 * We only end up here if none of -m/-F/-c/-C or -f are
546 * given. The original args are therefore still in
550 return append_edit(argc
, argv
, prefix
, repo
);
552 fprintf(stderr
, _("Overwriting existing notes for object %s\n"),
553 oid_to_hex(&object
));
556 prepare_note_data(&object
, &d
, note
);
557 if (d
.buf
.len
|| allow_empty
) {
558 write_note_data(&d
, &new_note
);
559 if (add_note(t
, &object
, &new_note
, combine_notes_overwrite
))
560 BUG("combine_notes_overwrite failed");
561 commit_notes(the_repository
, t
,
562 "Notes added by 'git notes add'");
564 fprintf(stderr
, _("Removing note for object %s\n"),
565 oid_to_hex(&object
));
566 remove_note(t
, object
.hash
);
567 commit_notes(the_repository
, t
,
568 "Notes removed by 'git notes add'");
576 static int copy(int argc
, const char **argv
, const char *prefix
,
577 struct repository
*repo UNUSED
)
579 int retval
= 0, force
= 0, from_stdin
= 0;
580 const struct object_id
*from_note
, *note
;
581 const char *object_ref
;
582 struct object_id object
, from_obj
;
583 struct notes_tree
*t
;
584 const char *rewrite_cmd
= NULL
;
585 struct option options
[] = {
586 OPT__FORCE(&force
, N_("replace existing notes"), PARSE_OPT_NOCOMPLETE
),
587 OPT_BOOL(0, "stdin", &from_stdin
, N_("read objects from stdin")),
588 OPT_STRING(0, "for-rewrite", &rewrite_cmd
, N_("command"),
589 N_("load rewriting config for <command> (implies "
594 argc
= parse_options(argc
, argv
, prefix
, options
, git_notes_copy_usage
,
597 if (from_stdin
|| rewrite_cmd
) {
599 error(_("too many arguments"));
600 usage_with_options(git_notes_copy_usage
, options
);
602 return notes_copy_from_stdin(force
, rewrite_cmd
);
607 error(_("too few arguments"));
608 usage_with_options(git_notes_copy_usage
, options
);
611 error(_("too many arguments"));
612 usage_with_options(git_notes_copy_usage
, options
);
615 if (repo_get_oid(the_repository
, argv
[0], &from_obj
))
616 die(_("failed to resolve '%s' as a valid ref."), argv
[0]);
618 object_ref
= 1 < argc
? argv
[1] : "HEAD";
620 if (repo_get_oid(the_repository
, object_ref
, &object
))
621 die(_("failed to resolve '%s' as a valid ref."), object_ref
);
623 t
= init_notes_check("copy", NOTES_INIT_WRITABLE
);
624 note
= get_note(t
, &object
);
628 retval
= error(_("Cannot copy notes. Found existing "
629 "notes for object %s. Use '-f' to "
630 "overwrite existing notes"),
631 oid_to_hex(&object
));
634 fprintf(stderr
, _("Overwriting existing notes for object %s\n"),
635 oid_to_hex(&object
));
638 from_note
= get_note(t
, &from_obj
);
640 retval
= error(_("missing notes on source object %s. Cannot "
641 "copy."), oid_to_hex(&from_obj
));
645 if (add_note(t
, &object
, from_note
, combine_notes_overwrite
))
646 BUG("combine_notes_overwrite failed");
647 commit_notes(the_repository
, t
,
648 "Notes added by 'git notes copy'");
654 static int append_edit(int argc
, const char **argv
, const char *prefix
,
655 struct repository
*repo UNUSED
)
658 const char *object_ref
;
659 struct notes_tree
*t
;
660 struct object_id object
, new_note
;
661 const struct object_id
*note
;
663 const char * const *usage
;
664 struct note_data d
= { .buf
= STRBUF_INIT
, .stripspace
= UNSPECIFIED
};
665 struct option options
[] = {
666 OPT_CALLBACK_F('m', "message", &d
, N_("message"),
667 N_("note contents as a string"), PARSE_OPT_NONEG
,
669 OPT_CALLBACK_F('F', "file", &d
, N_("file"),
670 N_("note contents in a file"), PARSE_OPT_NONEG
,
672 OPT_CALLBACK_F('c', "reedit-message", &d
, N_("object"),
673 N_("reuse and edit specified note object"), PARSE_OPT_NONEG
,
675 OPT_CALLBACK_F('C', "reuse-message", &d
, N_("object"),
676 N_("reuse specified note object"), PARSE_OPT_NONEG
,
678 OPT_BOOL('e', "edit", &d
.use_editor
,
679 N_("edit note message in editor")),
680 OPT_BOOL(0, "allow-empty", &allow_empty
,
681 N_("allow storing empty note")),
682 OPT_CALLBACK_F(0, "separator", &separator
,
683 N_("<paragraph-break>"),
684 N_("insert <paragraph-break> between paragraphs"),
685 PARSE_OPT_OPTARG
, parse_separator_arg
),
686 OPT_BOOL(0, "stripspace", &d
.stripspace
,
687 N_("remove unnecessary whitespace")),
690 int edit
= !strcmp(argv
[0], "edit");
692 usage
= edit
? git_notes_edit_usage
: git_notes_append_usage
;
693 argc
= parse_options(argc
, argv
, prefix
, options
, usage
,
694 PARSE_OPT_KEEP_ARGV0
);
697 error(_("too many arguments"));
698 usage_with_options(usage
, options
);
704 fprintf(stderr
, _("The -m/-F/-c/-C options have been "
705 "deprecated for the 'edit' subcommand.\n"
706 "Please use 'git notes add -f -m/-F/-c/-C' "
710 object_ref
= 1 < argc
? argv
[1] : "HEAD";
712 if (repo_get_oid(the_repository
, object_ref
, &object
))
713 die(_("failed to resolve '%s' as a valid ref."), object_ref
);
715 t
= init_notes_check(argv
[0], NOTES_INIT_WRITABLE
);
716 note
= get_note(t
, &object
);
718 prepare_note_data(&object
, &d
, edit
&& note
? note
: NULL
);
721 /* Append buf to previous note contents */
723 enum object_type type
;
724 struct strbuf buf
= STRBUF_INIT
;
725 char *prev_buf
= repo_read_object_file(the_repository
, note
, &type
, &size
);
728 die(_("unable to read %s"), oid_to_hex(note
));
730 strbuf_add(&buf
, prev_buf
, size
);
731 if (d
.buf
.len
&& size
)
732 append_separator(&buf
);
733 strbuf_insert(&d
.buf
, 0, buf
.buf
, buf
.len
);
736 strbuf_release(&buf
);
739 if (d
.buf
.len
|| allow_empty
) {
740 write_note_data(&d
, &new_note
);
741 if (add_note(t
, &object
, &new_note
, combine_notes_overwrite
))
742 BUG("combine_notes_overwrite failed");
743 logmsg
= xstrfmt("Notes added by 'git notes %s'", argv
[0]);
745 fprintf(stderr
, _("Removing note for object %s\n"),
746 oid_to_hex(&object
));
747 remove_note(t
, object
.hash
);
748 logmsg
= xstrfmt("Notes removed by 'git notes %s'", argv
[0]);
750 commit_notes(the_repository
, t
, logmsg
);
758 static int show(int argc
, const char **argv
, const char *prefix
,
759 struct repository
*repo UNUSED
)
761 const char *object_ref
;
762 struct notes_tree
*t
;
763 struct object_id object
;
764 const struct object_id
*note
;
766 struct option options
[] = {
770 argc
= parse_options(argc
, argv
, prefix
, options
, git_notes_show_usage
,
774 error(_("too many arguments"));
775 usage_with_options(git_notes_show_usage
, options
);
778 object_ref
= argc
? argv
[0] : "HEAD";
780 if (repo_get_oid(the_repository
, object_ref
, &object
))
781 die(_("failed to resolve '%s' as a valid ref."), object_ref
);
783 t
= init_notes_check("show", 0);
784 note
= get_note(t
, &object
);
787 retval
= error(_("no note found for object %s."),
788 oid_to_hex(&object
));
790 const char *show_args
[3] = {"show", oid_to_hex(note
), NULL
};
791 retval
= execv_git_cmd(show_args
);
797 static int merge_abort(struct notes_merge_options
*o
)
802 * Remove .git/NOTES_MERGE_PARTIAL and .git/NOTES_MERGE_REF, and call
803 * notes_merge_abort() to remove .git/NOTES_MERGE_WORKTREE.
806 if (refs_delete_ref(get_main_ref_store(the_repository
), NULL
, "NOTES_MERGE_PARTIAL", NULL
, 0))
807 ret
+= error(_("failed to delete ref NOTES_MERGE_PARTIAL"));
808 if (refs_delete_ref(get_main_ref_store(the_repository
), NULL
, "NOTES_MERGE_REF", NULL
, REF_NO_DEREF
))
809 ret
+= error(_("failed to delete ref NOTES_MERGE_REF"));
810 if (notes_merge_abort(o
))
811 ret
+= error(_("failed to remove 'git notes merge' worktree"));
815 static int merge_commit(struct notes_merge_options
*o
)
817 struct strbuf msg
= STRBUF_INIT
;
818 struct object_id oid
, parent_oid
;
819 struct notes_tree t
= {0};
820 struct commit
*partial
;
821 struct pretty_print_context pretty_ctx
;
822 void *local_ref_to_free
;
826 * Read partial merge result from .git/NOTES_MERGE_PARTIAL,
827 * and target notes ref from .git/NOTES_MERGE_REF.
830 if (repo_get_oid(the_repository
, "NOTES_MERGE_PARTIAL", &oid
))
831 die(_("failed to read ref NOTES_MERGE_PARTIAL"));
832 else if (!(partial
= lookup_commit_reference(the_repository
, &oid
)))
833 die(_("could not find commit from NOTES_MERGE_PARTIAL."));
834 else if (repo_parse_commit(the_repository
, partial
))
835 die(_("could not parse commit from NOTES_MERGE_PARTIAL."));
837 if (partial
->parents
)
838 oidcpy(&parent_oid
, &partial
->parents
->item
->object
.oid
);
840 oidclr(&parent_oid
, the_repository
->hash_algo
);
842 init_notes(&t
, "NOTES_MERGE_PARTIAL", combine_notes_overwrite
, 0);
844 o
->local_ref
= local_ref_to_free
=
845 refs_resolve_refdup(get_main_ref_store(the_repository
),
846 "NOTES_MERGE_REF", 0, &oid
, NULL
);
848 die(_("failed to resolve NOTES_MERGE_REF"));
850 if (notes_merge_commit(o
, &t
, partial
, &oid
))
851 die(_("failed to finalize notes merge"));
853 /* Reuse existing commit message in reflog message */
854 memset(&pretty_ctx
, 0, sizeof(pretty_ctx
));
855 repo_format_commit_message(the_repository
, partial
, "%s", &msg
,
858 strbuf_insertstr(&msg
, 0, "notes: ");
859 refs_update_ref(get_main_ref_store(the_repository
), msg
.buf
,
861 is_null_oid(&parent_oid
) ? NULL
: &parent_oid
,
862 0, UPDATE_REFS_DIE_ON_ERR
);
865 strbuf_release(&msg
);
866 ret
= merge_abort(o
);
867 free(local_ref_to_free
);
871 static int git_config_get_notes_strategy(const char *key
,
872 enum notes_merge_strategy
*strategy
)
876 if (git_config_get_string(key
, &value
))
878 if (parse_notes_merge_strategy(value
, strategy
))
879 git_die_config(the_repository
, key
, _("unknown notes merge strategy %s"), value
);
885 static int merge(int argc
, const char **argv
, const char *prefix
,
886 struct repository
*repo UNUSED
)
888 struct strbuf remote_ref
= STRBUF_INIT
, msg
= STRBUF_INIT
;
889 struct object_id result_oid
;
890 struct notes_tree
*t
;
891 struct notes_merge_options o
;
892 int do_merge
= 0, do_commit
= 0, do_abort
= 0;
893 int verbosity
= 0, result
;
894 const char *strategy
= NULL
;
895 struct option options
[] = {
896 OPT_GROUP(N_("General options")),
897 OPT__VERBOSITY(&verbosity
),
898 OPT_GROUP(N_("Merge options")),
899 OPT_STRING('s', "strategy", &strategy
, N_("strategy"),
900 N_("resolve notes conflicts using the given strategy "
901 "(manual/ours/theirs/union/cat_sort_uniq)")),
902 OPT_GROUP(N_("Committing unmerged notes")),
903 OPT_SET_INT_F(0, "commit", &do_commit
,
904 N_("finalize notes merge by committing unmerged notes"),
906 OPT_GROUP(N_("Aborting notes merge resolution")),
907 OPT_SET_INT_F(0, "abort", &do_abort
,
908 N_("abort notes merge"),
914 argc
= parse_options(argc
, argv
, prefix
, options
,
915 git_notes_merge_usage
, 0);
917 if (strategy
|| do_commit
+ do_abort
== 0)
919 if (do_merge
+ do_commit
+ do_abort
!= 1) {
920 error(_("cannot mix --commit, --abort or -s/--strategy"));
921 usage_with_options(git_notes_merge_usage
, options
);
924 if (do_merge
&& argc
!= 1) {
925 error(_("must specify a notes ref to merge"));
926 usage_with_options(git_notes_merge_usage
, options
);
927 } else if (!do_merge
&& argc
) {
928 error(_("too many arguments"));
929 usage_with_options(git_notes_merge_usage
, options
);
932 init_notes_merge_options(the_repository
, &o
);
933 o
.verbosity
= verbosity
+ NOTES_MERGE_VERBOSITY_DEFAULT
;
936 return merge_abort(&o
);
938 return merge_commit(&o
);
940 notes_ref
= default_notes_ref(the_repository
);
941 o
.local_ref
= notes_ref
;
942 strbuf_addstr(&remote_ref
, argv
[0]);
943 expand_loose_notes_ref(&remote_ref
);
944 o
.remote_ref
= remote_ref
.buf
;
946 t
= init_notes_check("merge", NOTES_INIT_WRITABLE
);
949 if (parse_notes_merge_strategy(strategy
, &o
.strategy
)) {
950 error(_("unknown -s/--strategy: %s"), strategy
);
951 usage_with_options(git_notes_merge_usage
, options
);
954 struct strbuf merge_key
= STRBUF_INIT
;
955 const char *short_ref
= NULL
;
957 if (!skip_prefix(o
.local_ref
, "refs/notes/", &short_ref
))
958 BUG("local ref %s is outside of refs/notes/",
961 strbuf_addf(&merge_key
, "notes.%s.mergeStrategy", short_ref
);
963 if (git_config_get_notes_strategy(merge_key
.buf
, &o
.strategy
))
964 git_config_get_notes_strategy("notes.mergeStrategy", &o
.strategy
);
966 strbuf_release(&merge_key
);
969 strbuf_addf(&msg
, "notes: Merged notes from %s into %s",
970 remote_ref
.buf
, notes_ref
);
971 strbuf_add(&(o
.commit_msg
), msg
.buf
+ 7, msg
.len
- 7); /* skip "notes: " */
973 result
= notes_merge(&o
, t
, &result_oid
);
975 if (result
>= 0) /* Merge resulted (trivially) in result_oid */
976 /* Update default notes ref with new commit */
977 refs_update_ref(get_main_ref_store(the_repository
), msg
.buf
,
978 notes_ref
, &result_oid
, NULL
, 0,
979 UPDATE_REFS_DIE_ON_ERR
);
980 else { /* Merge has unresolved conflicts */
981 struct worktree
**worktrees
;
982 const struct worktree
*wt
;
985 /* Update .git/NOTES_MERGE_PARTIAL with partial merge result */
986 refs_update_ref(get_main_ref_store(the_repository
), msg
.buf
,
987 "NOTES_MERGE_PARTIAL", &result_oid
, NULL
,
988 0, UPDATE_REFS_DIE_ON_ERR
);
989 /* Store ref-to-be-updated into .git/NOTES_MERGE_REF */
990 worktrees
= get_worktrees();
991 wt
= find_shared_symref(worktrees
, "NOTES_MERGE_REF",
994 die(_("a notes merge into %s is already in-progress at %s"),
995 notes_ref
, wt
->path
);
996 free_worktrees(worktrees
);
997 if (refs_update_symref(get_main_ref_store(the_repository
), "NOTES_MERGE_REF", notes_ref
, NULL
))
998 die(_("failed to store link to current notes ref (%s)"),
1001 path
= repo_git_path(the_repository
, NOTES_MERGE_WORKTREE
);
1002 fprintf(stderr
, _("Automatic notes merge failed. Fix conflicts in %s "
1003 "and commit the result with 'git notes merge --commit', "
1004 "or abort the merge with 'git notes merge --abort'.\n"),
1011 strbuf_release(&remote_ref
);
1012 strbuf_release(&msg
);
1013 return result
< 0; /* return non-zero on conflicts */
1016 #define IGNORE_MISSING 1
1018 static int remove_one_note(struct notes_tree
*t
, const char *name
, unsigned flag
)
1021 struct object_id oid
;
1022 if (repo_get_oid(the_repository
, name
, &oid
))
1023 return error(_("Failed to resolve '%s' as a valid ref."), name
);
1024 status
= remove_note(t
, oid
.hash
);
1026 fprintf(stderr
, _("Object %s has no note\n"), name
);
1028 fprintf(stderr
, _("Removing note for object %s\n"), name
);
1029 return (flag
& IGNORE_MISSING
) ? 0 : status
;
1032 static int remove_cmd(int argc
, const char **argv
, const char *prefix
,
1033 struct repository
*repo UNUSED
)
1037 struct option options
[] = {
1038 OPT_BIT(0, "ignore-missing", &flag
,
1039 N_("attempt to remove non-existent note is not an error"),
1041 OPT_BOOL(0, "stdin", &from_stdin
,
1042 N_("read object names from the standard input")),
1045 struct notes_tree
*t
;
1048 argc
= parse_options(argc
, argv
, prefix
, options
,
1049 git_notes_remove_usage
, 0);
1051 t
= init_notes_check("remove", NOTES_INIT_WRITABLE
);
1053 if (!argc
&& !from_stdin
) {
1054 retval
= remove_one_note(t
, "HEAD", flag
);
1057 retval
|= remove_one_note(t
, *argv
, flag
);
1062 struct strbuf sb
= STRBUF_INIT
;
1063 while (strbuf_getwholeline(&sb
, stdin
, '\n') != EOF
) {
1065 retval
|= remove_one_note(t
, sb
.buf
, flag
);
1067 strbuf_release(&sb
);
1070 commit_notes(the_repository
, t
,
1071 "Notes removed by 'git notes remove'");
1076 static int prune(int argc
, const char **argv
, const char *prefix
,
1077 struct repository
*repo UNUSED
)
1079 struct notes_tree
*t
;
1080 int show_only
= 0, verbose
= 0;
1081 struct option options
[] = {
1082 OPT__DRY_RUN(&show_only
, N_("do not remove, show only")),
1083 OPT__VERBOSE(&verbose
, N_("report pruned notes")),
1087 argc
= parse_options(argc
, argv
, prefix
, options
, git_notes_prune_usage
,
1091 error(_("too many arguments"));
1092 usage_with_options(git_notes_prune_usage
, options
);
1095 t
= init_notes_check("prune", NOTES_INIT_WRITABLE
);
1097 prune_notes(t
, (verbose
? NOTES_PRUNE_VERBOSE
: 0) |
1098 (show_only
? NOTES_PRUNE_VERBOSE
|NOTES_PRUNE_DRYRUN
: 0) );
1100 commit_notes(the_repository
, t
,
1101 "Notes removed by 'git notes prune'");
1106 static int get_ref(int argc
, const char **argv
, const char *prefix
,
1107 struct repository
*repo UNUSED
)
1109 struct option options
[] = { OPT_END() };
1111 argc
= parse_options(argc
, argv
, prefix
, options
,
1112 git_notes_get_ref_usage
, 0);
1115 error(_("too many arguments"));
1116 usage_with_options(git_notes_get_ref_usage
, options
);
1119 notes_ref
= default_notes_ref(the_repository
);
1125 int cmd_notes(int argc
,
1128 struct repository
*repo
)
1130 const char *override_notes_ref
= NULL
;
1131 parse_opt_subcommand_fn
*fn
= NULL
;
1132 struct option options
[] = {
1133 OPT_STRING(0, "ref", &override_notes_ref
, N_("notes-ref"),
1134 N_("use notes from <notes-ref>")),
1135 OPT_SUBCOMMAND("list", &fn
, list
),
1136 OPT_SUBCOMMAND("add", &fn
, add
),
1137 OPT_SUBCOMMAND("copy", &fn
, copy
),
1138 OPT_SUBCOMMAND("append", &fn
, append_edit
),
1139 OPT_SUBCOMMAND("edit", &fn
, append_edit
),
1140 OPT_SUBCOMMAND("show", &fn
, show
),
1141 OPT_SUBCOMMAND("merge", &fn
, merge
),
1142 OPT_SUBCOMMAND("remove", &fn
, remove_cmd
),
1143 OPT_SUBCOMMAND("prune", &fn
, prune
),
1144 OPT_SUBCOMMAND("get-ref", &fn
, get_ref
),
1148 git_config(git_default_config
, NULL
);
1149 argc
= parse_options(argc
, argv
, prefix
, options
, git_notes_usage
,
1150 PARSE_OPT_SUBCOMMAND_OPTIONAL
);
1153 error(_("unknown subcommand: `%s'"), argv
[0]);
1154 usage_with_options(git_notes_usage
, options
);
1159 if (override_notes_ref
) {
1160 struct strbuf sb
= STRBUF_INIT
;
1161 strbuf_addstr(&sb
, override_notes_ref
);
1162 expand_notes_ref(&sb
);
1163 setenv("GIT_NOTES_REF", sb
.buf
, 1);
1164 strbuf_release(&sb
);
1167 return !!fn(argc
, argv
, prefix
, repo
);