From c8bae7493d2f2910b57f13ded012e86bdcfb0532 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 16:47:53 +0200 Subject: Adding upstream version 1:2.39.2. Signed-off-by: Daniel Baumann --- builtin/notes.c | 1035 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1035 insertions(+) create mode 100644 builtin/notes.c (limited to 'builtin/notes.c') diff --git a/builtin/notes.c b/builtin/notes.c new file mode 100644 index 0000000..80d9dfd --- /dev/null +++ b/builtin/notes.c @@ -0,0 +1,1035 @@ +/* + * Builtin "git notes" + * + * Copyright (c) 2010 Johan Herland + * + * Based on git-notes.sh by Johannes Schindelin, + * and builtin/tag.c by Kristian Høgsberg and Carlos Rica. + */ + +#include "cache.h" +#include "config.h" +#include "builtin.h" +#include "notes.h" +#include "object-store.h" +#include "repository.h" +#include "blob.h" +#include "pretty.h" +#include "refs.h" +#include "exec-cmd.h" +#include "run-command.h" +#include "parse-options.h" +#include "string-list.h" +#include "notes-merge.h" +#include "notes-utils.h" +#include "worktree.h" + +static const char * const git_notes_usage[] = { + N_("git notes [--ref ] [list []]"), + N_("git notes [--ref ] add [-f] [--allow-empty] [-m | -F | (-c | -C) ] []"), + N_("git notes [--ref ] copy [-f] "), + N_("git notes [--ref ] append [--allow-empty] [-m | -F | (-c | -C) ] []"), + N_("git notes [--ref ] edit [--allow-empty] []"), + N_("git notes [--ref ] show []"), + N_("git notes [--ref ] merge [-v | -q] [-s ] "), + "git notes merge --commit [-v | -q]", + "git notes merge --abort [-v | -q]", + N_("git notes [--ref ] remove [...]"), + N_("git notes [--ref ] prune [-n] [-v]"), + N_("git notes [--ref ] get-ref"), + NULL +}; + +static const char * const git_notes_list_usage[] = { + N_("git notes [list []]"), + NULL +}; + +static const char * const git_notes_add_usage[] = { + N_("git notes add [] []"), + NULL +}; + +static const char * const git_notes_copy_usage[] = { + N_("git notes copy [] "), + N_("git notes copy --stdin [ ]..."), + NULL +}; + +static const char * const git_notes_append_usage[] = { + N_("git notes append [] []"), + NULL +}; + +static const char * const git_notes_edit_usage[] = { + N_("git notes edit []"), + NULL +}; + +static const char * const git_notes_show_usage[] = { + N_("git notes show []"), + NULL +}; + +static const char * const git_notes_merge_usage[] = { + N_("git notes merge [] "), + N_("git notes merge --commit []"), + N_("git notes merge --abort []"), + NULL +}; + +static const char * const git_notes_remove_usage[] = { + N_("git notes remove []"), + NULL +}; + +static const char * const git_notes_prune_usage[] = { + N_("git notes prune []"), + NULL +}; + +static const char * const git_notes_get_ref_usage[] = { + "git notes get-ref", + NULL +}; + +static const char note_template[] = + N_("Write/edit the notes for the following object:"); + +struct note_data { + int given; + int use_editor; + char *edit_path; + struct strbuf buf; +}; + +static void free_note_data(struct note_data *d) +{ + if (d->edit_path) { + unlink_or_warn(d->edit_path); + free(d->edit_path); + } + strbuf_release(&d->buf); +} + +static int list_each_note(const struct object_id *object_oid, + const struct object_id *note_oid, char *note_path, + void *cb_data) +{ + printf("%s %s\n", oid_to_hex(note_oid), oid_to_hex(object_oid)); + return 0; +} + +static void copy_obj_to_fd(int fd, const struct object_id *oid) +{ + unsigned long size; + enum object_type type; + char *buf = read_object_file(oid, &type, &size); + if (buf) { + if (size) + write_or_die(fd, buf, size); + free(buf); + } +} + +static void write_commented_object(int fd, const struct object_id *object) +{ + struct child_process show = CHILD_PROCESS_INIT; + struct strbuf buf = STRBUF_INIT; + struct strbuf cbuf = STRBUF_INIT; + + /* Invoke "git show --stat --no-notes $object" */ + strvec_pushl(&show.args, "show", "--stat", "--no-notes", + oid_to_hex(object), NULL); + show.no_stdin = 1; + show.out = -1; + show.err = 0; + show.git_cmd = 1; + if (start_command(&show)) + die(_("unable to start 'show' for object '%s'"), + oid_to_hex(object)); + + if (strbuf_read(&buf, show.out, 0) < 0) + die_errno(_("could not read 'show' output")); + strbuf_add_commented_lines(&cbuf, buf.buf, buf.len); + write_or_die(fd, cbuf.buf, cbuf.len); + + strbuf_release(&cbuf); + strbuf_release(&buf); + + if (finish_command(&show)) + die(_("failed to finish 'show' for object '%s'"), + oid_to_hex(object)); +} + +static void prepare_note_data(const struct object_id *object, struct note_data *d, + const struct object_id *old_note) +{ + if (d->use_editor || !d->given) { + int fd; + struct strbuf buf = STRBUF_INIT; + + /* write the template message before editing: */ + d->edit_path = git_pathdup("NOTES_EDITMSG"); + fd = xopen(d->edit_path, O_CREAT | O_TRUNC | O_WRONLY, 0600); + + if (d->given) + write_or_die(fd, d->buf.buf, d->buf.len); + else if (old_note) + copy_obj_to_fd(fd, old_note); + + strbuf_addch(&buf, '\n'); + strbuf_add_commented_lines(&buf, "\n", strlen("\n")); + strbuf_add_commented_lines(&buf, _(note_template), strlen(_(note_template))); + strbuf_add_commented_lines(&buf, "\n", strlen("\n")); + write_or_die(fd, buf.buf, buf.len); + + write_commented_object(fd, object); + + close(fd); + strbuf_release(&buf); + strbuf_reset(&d->buf); + + if (launch_editor(d->edit_path, &d->buf, NULL)) { + die(_("please supply the note contents using either -m or -F option")); + } + strbuf_stripspace(&d->buf, 1); + } +} + +static void write_note_data(struct note_data *d, struct object_id *oid) +{ + if (write_object_file(d->buf.buf, d->buf.len, OBJ_BLOB, oid)) { + int status = die_message(_("unable to write note object")); + + if (d->edit_path) + die_message(_("the note contents have been left in %s"), + d->edit_path); + exit(status); + } +} + +static int parse_msg_arg(const struct option *opt, const char *arg, int unset) +{ + struct note_data *d = opt->value; + + BUG_ON_OPT_NEG(unset); + + strbuf_grow(&d->buf, strlen(arg) + 2); + if (d->buf.len) + strbuf_addch(&d->buf, '\n'); + strbuf_addstr(&d->buf, arg); + strbuf_stripspace(&d->buf, 0); + + d->given = 1; + return 0; +} + +static int parse_file_arg(const struct option *opt, const char *arg, int unset) +{ + struct note_data *d = opt->value; + + BUG_ON_OPT_NEG(unset); + + if (d->buf.len) + strbuf_addch(&d->buf, '\n'); + if (!strcmp(arg, "-")) { + if (strbuf_read(&d->buf, 0, 1024) < 0) + die_errno(_("cannot read '%s'"), arg); + } else if (strbuf_read_file(&d->buf, arg, 1024) < 0) + die_errno(_("could not open or read '%s'"), arg); + strbuf_stripspace(&d->buf, 0); + + d->given = 1; + return 0; +} + +static int parse_reuse_arg(const struct option *opt, const char *arg, int unset) +{ + struct note_data *d = opt->value; + char *buf; + struct object_id object; + enum object_type type; + unsigned long len; + + BUG_ON_OPT_NEG(unset); + + if (d->buf.len) + strbuf_addch(&d->buf, '\n'); + + if (get_oid(arg, &object)) + die(_("failed to resolve '%s' as a valid ref."), arg); + if (!(buf = read_object_file(&object, &type, &len))) + die(_("failed to read object '%s'."), arg); + if (type != OBJ_BLOB) { + free(buf); + die(_("cannot read note data from non-blob object '%s'."), arg); + } + strbuf_add(&d->buf, buf, len); + free(buf); + + d->given = 1; + return 0; +} + +static int parse_reedit_arg(const struct option *opt, const char *arg, int unset) +{ + struct note_data *d = opt->value; + BUG_ON_OPT_NEG(unset); + d->use_editor = 1; + return parse_reuse_arg(opt, arg, unset); +} + +static int notes_copy_from_stdin(int force, const char *rewrite_cmd) +{ + struct strbuf buf = STRBUF_INIT; + struct notes_rewrite_cfg *c = NULL; + struct notes_tree *t = NULL; + int ret = 0; + const char *msg = "Notes added by 'git notes copy'"; + + if (rewrite_cmd) { + c = init_copy_notes_for_rewrite(rewrite_cmd); + if (!c) + return 0; + } else { + init_notes(NULL, NULL, NULL, NOTES_INIT_WRITABLE); + t = &default_notes_tree; + } + + while (strbuf_getline_lf(&buf, stdin) != EOF) { + struct object_id from_obj, to_obj; + struct strbuf **split; + int err; + + split = strbuf_split(&buf, ' '); + if (!split[0] || !split[1]) + die(_("malformed input line: '%s'."), buf.buf); + strbuf_rtrim(split[0]); + strbuf_rtrim(split[1]); + if (get_oid(split[0]->buf, &from_obj)) + die(_("failed to resolve '%s' as a valid ref."), split[0]->buf); + if (get_oid(split[1]->buf, &to_obj)) + die(_("failed to resolve '%s' as a valid ref."), split[1]->buf); + + if (rewrite_cmd) + err = copy_note_for_rewrite(c, &from_obj, &to_obj); + else + err = copy_note(t, &from_obj, &to_obj, force, + combine_notes_overwrite); + + if (err) { + error(_("failed to copy notes from '%s' to '%s'"), + split[0]->buf, split[1]->buf); + ret = 1; + } + + strbuf_list_free(split); + } + + if (!rewrite_cmd) { + commit_notes(the_repository, t, msg); + free_notes(t); + } else { + finish_copy_notes_for_rewrite(the_repository, c, msg); + } + strbuf_release(&buf); + return ret; +} + +static struct notes_tree *init_notes_check(const char *subcommand, + int flags) +{ + struct notes_tree *t; + const char *ref; + init_notes(NULL, NULL, NULL, flags); + t = &default_notes_tree; + + ref = (flags & NOTES_INIT_WRITABLE) ? t->update_ref : t->ref; + if (!starts_with(ref, "refs/notes/")) + /* + * TRANSLATORS: the first %s will be replaced by a git + * notes command: 'add', 'merge', 'remove', etc. + */ + die(_("refusing to %s notes in %s (outside of refs/notes/)"), + subcommand, ref); + return t; +} + +static int list(int argc, const char **argv, const char *prefix) +{ + struct notes_tree *t; + struct object_id object; + const struct object_id *note; + int retval = -1; + struct option options[] = { + OPT_END() + }; + + if (argc) + argc = parse_options(argc, argv, prefix, options, + git_notes_list_usage, 0); + + if (1 < argc) { + error(_("too many arguments")); + usage_with_options(git_notes_list_usage, options); + } + + t = init_notes_check("list", 0); + if (argc) { + if (get_oid(argv[0], &object)) + die(_("failed to resolve '%s' as a valid ref."), argv[0]); + note = get_note(t, &object); + if (note) { + puts(oid_to_hex(note)); + retval = 0; + } else + retval = error(_("no note found for object %s."), + oid_to_hex(&object)); + } else + retval = for_each_note(t, 0, list_each_note, NULL); + + free_notes(t); + return retval; +} + +static int append_edit(int argc, const char **argv, const char *prefix); + +static int add(int argc, const char **argv, const char *prefix) +{ + int force = 0, allow_empty = 0; + const char *object_ref; + struct notes_tree *t; + struct object_id object, new_note; + const struct object_id *note; + struct note_data d = { 0, 0, NULL, STRBUF_INIT }; + struct option options[] = { + OPT_CALLBACK_F('m', "message", &d, N_("message"), + N_("note contents as a string"), PARSE_OPT_NONEG, + parse_msg_arg), + OPT_CALLBACK_F('F', "file", &d, N_("file"), + N_("note contents in a file"), PARSE_OPT_NONEG, + parse_file_arg), + OPT_CALLBACK_F('c', "reedit-message", &d, N_("object"), + N_("reuse and edit specified note object"), PARSE_OPT_NONEG, + parse_reedit_arg), + OPT_CALLBACK_F('C', "reuse-message", &d, N_("object"), + N_("reuse specified note object"), PARSE_OPT_NONEG, + parse_reuse_arg), + OPT_BOOL(0, "allow-empty", &allow_empty, + N_("allow storing empty note")), + OPT__FORCE(&force, N_("replace existing notes"), PARSE_OPT_NOCOMPLETE), + OPT_END() + }; + + argc = parse_options(argc, argv, prefix, options, git_notes_add_usage, + PARSE_OPT_KEEP_ARGV0); + + if (2 < argc) { + error(_("too many arguments")); + usage_with_options(git_notes_add_usage, options); + } + + object_ref = argc > 1 ? argv[1] : "HEAD"; + + if (get_oid(object_ref, &object)) + die(_("failed to resolve '%s' as a valid ref."), object_ref); + + t = init_notes_check("add", NOTES_INIT_WRITABLE); + note = get_note(t, &object); + + if (note) { + if (!force) { + free_notes(t); + if (d.given) { + free_note_data(&d); + return error(_("Cannot add notes. " + "Found existing notes for object %s. " + "Use '-f' to overwrite existing notes"), + oid_to_hex(&object)); + } + /* + * Redirect to "edit" subcommand. + * + * We only end up here if none of -m/-F/-c/-C or -f are + * given. The original args are therefore still in + * argv[0-1]. + */ + argv[0] = "edit"; + return append_edit(argc, argv, prefix); + } + fprintf(stderr, _("Overwriting existing notes for object %s\n"), + oid_to_hex(&object)); + } + + prepare_note_data(&object, &d, note); + if (d.buf.len || allow_empty) { + write_note_data(&d, &new_note); + if (add_note(t, &object, &new_note, combine_notes_overwrite)) + BUG("combine_notes_overwrite failed"); + commit_notes(the_repository, t, + "Notes added by 'git notes add'"); + } else { + fprintf(stderr, _("Removing note for object %s\n"), + oid_to_hex(&object)); + remove_note(t, object.hash); + commit_notes(the_repository, t, + "Notes removed by 'git notes add'"); + } + + free_note_data(&d); + free_notes(t); + return 0; +} + +static int copy(int argc, const char **argv, const char *prefix) +{ + int retval = 0, force = 0, from_stdin = 0; + const struct object_id *from_note, *note; + const char *object_ref; + struct object_id object, from_obj; + struct notes_tree *t; + const char *rewrite_cmd = NULL; + struct option options[] = { + OPT__FORCE(&force, N_("replace existing notes"), PARSE_OPT_NOCOMPLETE), + OPT_BOOL(0, "stdin", &from_stdin, N_("read objects from stdin")), + OPT_STRING(0, "for-rewrite", &rewrite_cmd, N_("command"), + N_("load rewriting config for (implies " + "--stdin)")), + OPT_END() + }; + + argc = parse_options(argc, argv, prefix, options, git_notes_copy_usage, + 0); + + if (from_stdin || rewrite_cmd) { + if (argc) { + error(_("too many arguments")); + usage_with_options(git_notes_copy_usage, options); + } else { + return notes_copy_from_stdin(force, rewrite_cmd); + } + } + + if (argc < 1) { + error(_("too few arguments")); + usage_with_options(git_notes_copy_usage, options); + } + if (2 < argc) { + error(_("too many arguments")); + usage_with_options(git_notes_copy_usage, options); + } + + if (get_oid(argv[0], &from_obj)) + die(_("failed to resolve '%s' as a valid ref."), argv[0]); + + object_ref = 1 < argc ? argv[1] : "HEAD"; + + if (get_oid(object_ref, &object)) + die(_("failed to resolve '%s' as a valid ref."), object_ref); + + t = init_notes_check("copy", NOTES_INIT_WRITABLE); + note = get_note(t, &object); + + if (note) { + if (!force) { + retval = error(_("Cannot copy notes. Found existing " + "notes for object %s. Use '-f' to " + "overwrite existing notes"), + oid_to_hex(&object)); + goto out; + } + fprintf(stderr, _("Overwriting existing notes for object %s\n"), + oid_to_hex(&object)); + } + + from_note = get_note(t, &from_obj); + if (!from_note) { + retval = error(_("missing notes on source object %s. Cannot " + "copy."), oid_to_hex(&from_obj)); + goto out; + } + + if (add_note(t, &object, from_note, combine_notes_overwrite)) + BUG("combine_notes_overwrite failed"); + commit_notes(the_repository, t, + "Notes added by 'git notes copy'"); +out: + free_notes(t); + return retval; +} + +static int append_edit(int argc, const char **argv, const char *prefix) +{ + int allow_empty = 0; + const char *object_ref; + struct notes_tree *t; + struct object_id object, new_note; + const struct object_id *note; + char *logmsg; + const char * const *usage; + struct note_data d = { 0, 0, NULL, STRBUF_INIT }; + struct option options[] = { + OPT_CALLBACK_F('m', "message", &d, N_("message"), + N_("note contents as a string"), PARSE_OPT_NONEG, + parse_msg_arg), + OPT_CALLBACK_F('F', "file", &d, N_("file"), + N_("note contents in a file"), PARSE_OPT_NONEG, + parse_file_arg), + OPT_CALLBACK_F('c', "reedit-message", &d, N_("object"), + N_("reuse and edit specified note object"), PARSE_OPT_NONEG, + parse_reedit_arg), + OPT_CALLBACK_F('C', "reuse-message", &d, N_("object"), + N_("reuse specified note object"), PARSE_OPT_NONEG, + parse_reuse_arg), + OPT_BOOL(0, "allow-empty", &allow_empty, + N_("allow storing empty note")), + OPT_END() + }; + int edit = !strcmp(argv[0], "edit"); + + usage = edit ? git_notes_edit_usage : git_notes_append_usage; + argc = parse_options(argc, argv, prefix, options, usage, + PARSE_OPT_KEEP_ARGV0); + + if (2 < argc) { + error(_("too many arguments")); + usage_with_options(usage, options); + } + + if (d.given && edit) + fprintf(stderr, _("The -m/-F/-c/-C options have been deprecated " + "for the 'edit' subcommand.\n" + "Please use 'git notes add -f -m/-F/-c/-C' instead.\n")); + + object_ref = 1 < argc ? argv[1] : "HEAD"; + + if (get_oid(object_ref, &object)) + die(_("failed to resolve '%s' as a valid ref."), object_ref); + + t = init_notes_check(argv[0], NOTES_INIT_WRITABLE); + note = get_note(t, &object); + + prepare_note_data(&object, &d, edit && note ? note : NULL); + + if (note && !edit) { + /* Append buf to previous note contents */ + unsigned long size; + enum object_type type; + char *prev_buf = read_object_file(note, &type, &size); + + strbuf_grow(&d.buf, size + 1); + if (d.buf.len && prev_buf && size) + strbuf_insertstr(&d.buf, 0, "\n"); + if (prev_buf && size) + strbuf_insert(&d.buf, 0, prev_buf, size); + free(prev_buf); + } + + if (d.buf.len || allow_empty) { + write_note_data(&d, &new_note); + if (add_note(t, &object, &new_note, combine_notes_overwrite)) + BUG("combine_notes_overwrite failed"); + logmsg = xstrfmt("Notes added by 'git notes %s'", argv[0]); + } else { + fprintf(stderr, _("Removing note for object %s\n"), + oid_to_hex(&object)); + remove_note(t, object.hash); + logmsg = xstrfmt("Notes removed by 'git notes %s'", argv[0]); + } + commit_notes(the_repository, t, logmsg); + + free(logmsg); + free_note_data(&d); + free_notes(t); + return 0; +} + +static int show(int argc, const char **argv, const char *prefix) +{ + const char *object_ref; + struct notes_tree *t; + struct object_id object; + const struct object_id *note; + int retval; + struct option options[] = { + OPT_END() + }; + + argc = parse_options(argc, argv, prefix, options, git_notes_show_usage, + 0); + + if (1 < argc) { + error(_("too many arguments")); + usage_with_options(git_notes_show_usage, options); + } + + object_ref = argc ? argv[0] : "HEAD"; + + if (get_oid(object_ref, &object)) + die(_("failed to resolve '%s' as a valid ref."), object_ref); + + t = init_notes_check("show", 0); + note = get_note(t, &object); + + if (!note) + retval = error(_("no note found for object %s."), + oid_to_hex(&object)); + else { + const char *show_args[3] = {"show", oid_to_hex(note), NULL}; + retval = execv_git_cmd(show_args); + } + free_notes(t); + return retval; +} + +static int merge_abort(struct notes_merge_options *o) +{ + int ret = 0; + + /* + * Remove .git/NOTES_MERGE_PARTIAL and .git/NOTES_MERGE_REF, and call + * notes_merge_abort() to remove .git/NOTES_MERGE_WORKTREE. + */ + + if (delete_ref(NULL, "NOTES_MERGE_PARTIAL", NULL, 0)) + ret += error(_("failed to delete ref NOTES_MERGE_PARTIAL")); + if (delete_ref(NULL, "NOTES_MERGE_REF", NULL, REF_NO_DEREF)) + ret += error(_("failed to delete ref NOTES_MERGE_REF")); + if (notes_merge_abort(o)) + ret += error(_("failed to remove 'git notes merge' worktree")); + return ret; +} + +static int merge_commit(struct notes_merge_options *o) +{ + struct strbuf msg = STRBUF_INIT; + struct object_id oid, parent_oid; + struct notes_tree *t; + struct commit *partial; + struct pretty_print_context pretty_ctx; + void *local_ref_to_free; + int ret; + + /* + * Read partial merge result from .git/NOTES_MERGE_PARTIAL, + * and target notes ref from .git/NOTES_MERGE_REF. + */ + + if (get_oid("NOTES_MERGE_PARTIAL", &oid)) + die(_("failed to read ref NOTES_MERGE_PARTIAL")); + else if (!(partial = lookup_commit_reference(the_repository, &oid))) + die(_("could not find commit from NOTES_MERGE_PARTIAL.")); + else if (parse_commit(partial)) + die(_("could not parse commit from NOTES_MERGE_PARTIAL.")); + + if (partial->parents) + oidcpy(&parent_oid, &partial->parents->item->object.oid); + else + oidclr(&parent_oid); + + CALLOC_ARRAY(t, 1); + init_notes(t, "NOTES_MERGE_PARTIAL", combine_notes_overwrite, 0); + + o->local_ref = local_ref_to_free = + resolve_refdup("NOTES_MERGE_REF", 0, &oid, NULL); + if (!o->local_ref) + die(_("failed to resolve NOTES_MERGE_REF")); + + if (notes_merge_commit(o, t, partial, &oid)) + die(_("failed to finalize notes merge")); + + /* Reuse existing commit message in reflog message */ + memset(&pretty_ctx, 0, sizeof(pretty_ctx)); + format_commit_message(partial, "%s", &msg, &pretty_ctx); + strbuf_trim(&msg); + strbuf_insertstr(&msg, 0, "notes: "); + update_ref(msg.buf, o->local_ref, &oid, + is_null_oid(&parent_oid) ? NULL : &parent_oid, + 0, UPDATE_REFS_DIE_ON_ERR); + + free_notes(t); + strbuf_release(&msg); + ret = merge_abort(o); + free(local_ref_to_free); + return ret; +} + +static int git_config_get_notes_strategy(const char *key, + enum notes_merge_strategy *strategy) +{ + char *value; + + if (git_config_get_string(key, &value)) + return 1; + if (parse_notes_merge_strategy(value, strategy)) + git_die_config(key, _("unknown notes merge strategy %s"), value); + + free(value); + return 0; +} + +static int merge(int argc, const char **argv, const char *prefix) +{ + struct strbuf remote_ref = STRBUF_INIT, msg = STRBUF_INIT; + struct object_id result_oid; + struct notes_tree *t; + struct notes_merge_options o; + int do_merge = 0, do_commit = 0, do_abort = 0; + int verbosity = 0, result; + const char *strategy = NULL; + struct option options[] = { + OPT_GROUP(N_("General options")), + OPT__VERBOSITY(&verbosity), + OPT_GROUP(N_("Merge options")), + OPT_STRING('s', "strategy", &strategy, N_("strategy"), + N_("resolve notes conflicts using the given strategy " + "(manual/ours/theirs/union/cat_sort_uniq)")), + OPT_GROUP(N_("Committing unmerged notes")), + OPT_SET_INT_F(0, "commit", &do_commit, + N_("finalize notes merge by committing unmerged notes"), + 1, PARSE_OPT_NONEG), + OPT_GROUP(N_("Aborting notes merge resolution")), + OPT_SET_INT_F(0, "abort", &do_abort, + N_("abort notes merge"), + 1, PARSE_OPT_NONEG), + OPT_END() + }; + + argc = parse_options(argc, argv, prefix, options, + git_notes_merge_usage, 0); + + if (strategy || do_commit + do_abort == 0) + do_merge = 1; + if (do_merge + do_commit + do_abort != 1) { + error(_("cannot mix --commit, --abort or -s/--strategy")); + usage_with_options(git_notes_merge_usage, options); + } + + if (do_merge && argc != 1) { + error(_("must specify a notes ref to merge")); + usage_with_options(git_notes_merge_usage, options); + } else if (!do_merge && argc) { + error(_("too many arguments")); + usage_with_options(git_notes_merge_usage, options); + } + + init_notes_merge_options(the_repository, &o); + o.verbosity = verbosity + NOTES_MERGE_VERBOSITY_DEFAULT; + + if (do_abort) + return merge_abort(&o); + if (do_commit) + return merge_commit(&o); + + o.local_ref = default_notes_ref(); + strbuf_addstr(&remote_ref, argv[0]); + expand_loose_notes_ref(&remote_ref); + o.remote_ref = remote_ref.buf; + + t = init_notes_check("merge", NOTES_INIT_WRITABLE); + + if (strategy) { + if (parse_notes_merge_strategy(strategy, &o.strategy)) { + error(_("unknown -s/--strategy: %s"), strategy); + usage_with_options(git_notes_merge_usage, options); + } + } else { + struct strbuf merge_key = STRBUF_INIT; + const char *short_ref = NULL; + + if (!skip_prefix(o.local_ref, "refs/notes/", &short_ref)) + BUG("local ref %s is outside of refs/notes/", + o.local_ref); + + strbuf_addf(&merge_key, "notes.%s.mergeStrategy", short_ref); + + if (git_config_get_notes_strategy(merge_key.buf, &o.strategy)) + git_config_get_notes_strategy("notes.mergeStrategy", &o.strategy); + + strbuf_release(&merge_key); + } + + strbuf_addf(&msg, "notes: Merged notes from %s into %s", + remote_ref.buf, default_notes_ref()); + strbuf_add(&(o.commit_msg), msg.buf + 7, msg.len - 7); /* skip "notes: " */ + + result = notes_merge(&o, t, &result_oid); + + if (result >= 0) /* Merge resulted (trivially) in result_oid */ + /* Update default notes ref with new commit */ + update_ref(msg.buf, default_notes_ref(), &result_oid, NULL, 0, + UPDATE_REFS_DIE_ON_ERR); + else { /* Merge has unresolved conflicts */ + struct worktree **worktrees; + const struct worktree *wt; + /* Update .git/NOTES_MERGE_PARTIAL with partial merge result */ + update_ref(msg.buf, "NOTES_MERGE_PARTIAL", &result_oid, NULL, + 0, UPDATE_REFS_DIE_ON_ERR); + /* Store ref-to-be-updated into .git/NOTES_MERGE_REF */ + worktrees = get_worktrees(); + wt = find_shared_symref(worktrees, "NOTES_MERGE_REF", + default_notes_ref()); + if (wt) + die(_("a notes merge into %s is already in-progress at %s"), + default_notes_ref(), wt->path); + free_worktrees(worktrees); + if (create_symref("NOTES_MERGE_REF", default_notes_ref(), NULL)) + die(_("failed to store link to current notes ref (%s)"), + default_notes_ref()); + fprintf(stderr, _("Automatic notes merge failed. Fix conflicts in %s " + "and commit the result with 'git notes merge --commit', " + "or abort the merge with 'git notes merge --abort'.\n"), + git_path(NOTES_MERGE_WORKTREE)); + } + + free_notes(t); + strbuf_release(&remote_ref); + strbuf_release(&msg); + return result < 0; /* return non-zero on conflicts */ +} + +#define IGNORE_MISSING 1 + +static int remove_one_note(struct notes_tree *t, const char *name, unsigned flag) +{ + int status; + struct object_id oid; + if (get_oid(name, &oid)) + return error(_("Failed to resolve '%s' as a valid ref."), name); + status = remove_note(t, oid.hash); + if (status) + fprintf(stderr, _("Object %s has no note\n"), name); + else + fprintf(stderr, _("Removing note for object %s\n"), name); + return (flag & IGNORE_MISSING) ? 0 : status; +} + +static int remove_cmd(int argc, const char **argv, const char *prefix) +{ + unsigned flag = 0; + int from_stdin = 0; + struct option options[] = { + OPT_BIT(0, "ignore-missing", &flag, + N_("attempt to remove non-existent note is not an error"), + IGNORE_MISSING), + OPT_BOOL(0, "stdin", &from_stdin, + N_("read object names from the standard input")), + OPT_END() + }; + struct notes_tree *t; + int retval = 0; + + argc = parse_options(argc, argv, prefix, options, + git_notes_remove_usage, 0); + + t = init_notes_check("remove", NOTES_INIT_WRITABLE); + + if (!argc && !from_stdin) { + retval = remove_one_note(t, "HEAD", flag); + } else { + while (*argv) { + retval |= remove_one_note(t, *argv, flag); + argv++; + } + } + if (from_stdin) { + struct strbuf sb = STRBUF_INIT; + while (strbuf_getwholeline(&sb, stdin, '\n') != EOF) { + strbuf_rtrim(&sb); + retval |= remove_one_note(t, sb.buf, flag); + } + strbuf_release(&sb); + } + if (!retval) + commit_notes(the_repository, t, + "Notes removed by 'git notes remove'"); + free_notes(t); + return retval; +} + +static int prune(int argc, const char **argv, const char *prefix) +{ + struct notes_tree *t; + int show_only = 0, verbose = 0; + struct option options[] = { + OPT__DRY_RUN(&show_only, N_("do not remove, show only")), + OPT__VERBOSE(&verbose, N_("report pruned notes")), + OPT_END() + }; + + argc = parse_options(argc, argv, prefix, options, git_notes_prune_usage, + 0); + + if (argc) { + error(_("too many arguments")); + usage_with_options(git_notes_prune_usage, options); + } + + t = init_notes_check("prune", NOTES_INIT_WRITABLE); + + prune_notes(t, (verbose ? NOTES_PRUNE_VERBOSE : 0) | + (show_only ? NOTES_PRUNE_VERBOSE|NOTES_PRUNE_DRYRUN : 0) ); + if (!show_only) + commit_notes(the_repository, t, + "Notes removed by 'git notes prune'"); + free_notes(t); + return 0; +} + +static int get_ref(int argc, const char **argv, const char *prefix) +{ + struct option options[] = { OPT_END() }; + argc = parse_options(argc, argv, prefix, options, + git_notes_get_ref_usage, 0); + + if (argc) { + error(_("too many arguments")); + usage_with_options(git_notes_get_ref_usage, options); + } + + puts(default_notes_ref()); + return 0; +} + +int cmd_notes(int argc, const char **argv, const char *prefix) +{ + const char *override_notes_ref = NULL; + parse_opt_subcommand_fn *fn = NULL; + struct option options[] = { + OPT_STRING(0, "ref", &override_notes_ref, N_("notes-ref"), + N_("use notes from ")), + OPT_SUBCOMMAND("list", &fn, list), + OPT_SUBCOMMAND("add", &fn, add), + OPT_SUBCOMMAND("copy", &fn, copy), + OPT_SUBCOMMAND("append", &fn, append_edit), + OPT_SUBCOMMAND("edit", &fn, append_edit), + OPT_SUBCOMMAND("show", &fn, show), + OPT_SUBCOMMAND("merge", &fn, merge), + OPT_SUBCOMMAND("remove", &fn, remove_cmd), + OPT_SUBCOMMAND("prune", &fn, prune), + OPT_SUBCOMMAND("get-ref", &fn, get_ref), + OPT_END() + }; + + git_config(git_default_config, NULL); + argc = parse_options(argc, argv, prefix, options, git_notes_usage, + PARSE_OPT_SUBCOMMAND_OPTIONAL); + if (!fn) { + if (argc) { + error(_("unknown subcommand: `%s'"), argv[0]); + usage_with_options(git_notes_usage, options); + } + fn = list; + } + + if (override_notes_ref) { + struct strbuf sb = STRBUF_INIT; + strbuf_addstr(&sb, override_notes_ref); + expand_notes_ref(&sb); + setenv("GIT_NOTES_REF", sb.buf, 1); + strbuf_release(&sb); + } + + return !!fn(argc, argv, prefix); +} -- cgit v1.2.3