git/builtin/notes.c at master · gitgitgadget/git

1170 lines (1008 loc) · 32.5 KB
 * Builtin "git notes"
 * Copyright (c) 2010 Johan Herland <johan@herland.net>
 * Based on git-notes.sh by Johannes Schindelin,
 * and builtin/tag.c by Kristian Høgsberg and Carlos Rica.
#define USE_THE_REPOSITORY_VARIABLE
#include "builtin.h"
#include "config.h"
#include "editor.h"
#include "environment.h"
#include "gettext.h"
#include "hex.h"
#include "notes.h"
#include "object-file.h"
#include "object-name.h"
#include "odb.h"
#include "path.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"
#include "write-or-die.h"
static const char *separator = "\n";
static const char * const git_notes_usage[] = {
	N_("git notes [--ref <notes-ref>] [list [<object>]]"),
	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]"),
	N_("git notes [--ref <notes-ref>] copy [-f] <from-object> <to-object>"),
	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]"),
	N_("git notes [--ref <notes-ref>] edit [--allow-empty] [<object>]"),
	N_("git notes [--ref <notes-ref>] show [<object>]"),
	N_("git notes [--ref <notes-ref>] merge [-v | -q] [-s <strategy>] <notes-ref>"),
	"git notes merge --commit [-v | -q]",
	"git notes merge --abort [-v | -q]",
	N_("git notes [--ref <notes-ref>] remove [<object>...]"),
	N_("git notes [--ref <notes-ref>] prune [-n] [-v]"),
	N_("git notes [--ref <notes-ref>] get-ref"),
static const char * const git_notes_list_usage[] = {
	N_("git notes [list [<object>]]"),
static const char * const git_notes_add_usage[] = {
	N_("git notes add [<options>] [<object>]"),
static const char * const git_notes_copy_usage[] = {
	N_("git notes copy [<options>] <from-object> <to-object>"),
	N_("git notes copy --stdin [<from-object> <to-object>]..."),
static const char * const git_notes_append_usage[] = {
	N_("git notes append [<options>] [<object>]"),
static const char * const git_notes_edit_usage[] = {
	N_("git notes edit [<object>]"),
static const char * const git_notes_show_usage[] = {
	N_("git notes show [<object>]"),
static const char * const git_notes_merge_usage[] = {
	N_("git notes merge [<options>] <notes-ref>"),
	N_("git notes merge --commit [<options>]"),
	N_("git notes merge --abort [<options>]"),
static const char * const git_notes_remove_usage[] = {
	N_("git notes remove [<object>]"),
static const char * const git_notes_prune_usage[] = {
	N_("git notes prune [<options>]"),
static const char * const git_notes_get_ref_usage[] = {
	"git notes get-ref",
static const char note_template[] =
	N_("Write/edit the notes for the following object:");
enum notes_stripspace {
	UNSPECIFIED = -1,
	NO_STRIPSPACE = 0,
	STRIPSPACE = 1,
struct note_msg {
	enum notes_stripspace stripspace;
	struct strbuf buf;
struct note_data {
	int use_editor;
	int stripspace;
	char *edit_path;
	struct strbuf buf;
	struct note_msg **messages;
	size_t msg_nr;
	size_t msg_alloc;
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);
	while (d->msg_nr--) {
		strbuf_release(&d->messages[d->msg_nr]->buf);
		free(d->messages[d->msg_nr]);
	free(d->messages);
static int list_each_note(const struct object_id *object_oid,
			  const struct object_id *note_oid,
			  char *note_path UNUSED,
			  void *cb_data UNUSED)
	printf("%s %s\n", oid_to_hex(note_oid), oid_to_hex(object_oid));
static void copy_obj_to_fd(int fd, const struct object_id *oid)
	unsigned long size;
	enum object_type type;
	char *buf = odb_read_object(the_repository->objects, 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, comment_line_str);
	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->msg_nr) {
		struct strbuf buf = STRBUF_INIT;
		/* write the template message before editing: */
		d->edit_path = repo_git_path(the_repository, "NOTES_EDITMSG");
		fd = xopen(d->edit_path, O_CREAT | O_TRUNC | O_WRONLY, 0600);
		if (d->msg_nr)
			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"), comment_line_str);
		strbuf_add_commented_lines(&buf, _(note_template), strlen(_(note_template)),
					   comment_line_str);
		strbuf_add_commented_lines(&buf, "\n", strlen("\n"), comment_line_str);
		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"));
		if (d->stripspace)
			strbuf_stripspace(&d->buf, comment_line_str);
static void write_note_data(struct note_data *d, struct object_id *oid)
	if (odb_write_object(the_repository->objects, 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 void append_separator(struct strbuf *message)
	size_t sep_len = 0;
	if (!separator)
	else if ((sep_len = strlen(separator)) && separator[sep_len - 1] == '\n')
		strbuf_addstr(message, separator);
		strbuf_addf(message, "%s%s", separator, "\n");
static void concat_messages(struct note_data *d)
	struct strbuf msg = STRBUF_INIT;
	for (i = 0; i < d->msg_nr ; i++) {
		if (d->buf.len)
			append_separator(&d->buf);
		strbuf_add(&msg, d->messages[i]->buf.buf, d->messages[i]->buf.len);
		strbuf_addbuf(&d->buf, &msg);
		if ((d->stripspace == UNSPECIFIED &&
		     d->messages[i]->stripspace == STRIPSPACE) ||
		    d->stripspace == STRIPSPACE)
			strbuf_stripspace(&d->buf, NULL);
		strbuf_reset(&msg);
	strbuf_release(&msg);
static int parse_msg_arg(const struct option *opt, const char *arg, int unset)
	struct note_data *d = opt->value;
	struct note_msg *msg = xmalloc(sizeof(*msg));
	BUG_ON_OPT_NEG(unset);
	strbuf_init(&msg->buf, strlen(arg));
	strbuf_addstr(&msg->buf, arg);
	ALLOC_GROW_BY(d->messages, d->msg_nr, 1, d->msg_alloc);
	d->messages[d->msg_nr - 1] = msg;
	msg->stripspace = STRIPSPACE;
static int parse_file_arg(const struct option *opt, const char *arg, int unset)
	struct note_data *d = opt->value;
	struct note_msg *msg = xmalloc(sizeof(*msg));
	BUG_ON_OPT_NEG(unset);
	strbuf_init(&msg->buf , 0);
	if (!strcmp(arg, "-")) {
		if (strbuf_read(&msg->buf, 0, 1024) < 0)
			die_errno(_("cannot read '%s'"), arg);
	} else if (strbuf_read_file(&msg->buf, arg, 1024) < 0)
		die_errno(_("could not open or read '%s'"), arg);
	ALLOC_GROW_BY(d->messages, d->msg_nr, 1, d->msg_alloc);
	d->messages[d->msg_nr - 1] = msg;
	msg->stripspace = STRIPSPACE;
static int parse_reuse_arg(const struct option *opt, const char *arg, int unset)
	struct note_data *d = opt->value;
	struct note_msg *msg = xmalloc(sizeof(*msg));
	char *value;
	struct object_id object;
	enum object_type type;
	unsigned long len;
	BUG_ON_OPT_NEG(unset);
	strbuf_init(&msg->buf, 0);
	if (repo_get_oid(the_repository, arg, &object))
		die(_("failed to resolve '%s' as a valid ref."), arg);
	if (!(value = odb_read_object(the_repository->objects, &object, &type, &len)))
		die(_("failed to read object '%s'."), arg);
	if (type != OBJ_BLOB) {
		strbuf_release(&msg->buf);
		free(value);
		free(msg);
		die(_("cannot read note data from non-blob object '%s'."), arg);
	strbuf_add(&msg->buf, value, len);
	free(value);
	msg->buf.len = len;
	ALLOC_GROW_BY(d->messages, d->msg_nr, 1, d->msg_alloc);
	d->messages[d->msg_nr - 1] = msg;
	msg->stripspace = NO_STRIPSPACE;
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 parse_separator_arg(const struct option *opt, const char *arg,
			       int unset)
	if (unset)
		*(const char **)opt->value = NULL;
		*(const char **)opt->value = arg ? arg : "\n";
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
5276
 *msg = "Notes added by 'git notes copy'";
	if (rewrite_cmd) {
		c = init_copy_notes_for_rewrite(rewrite_cmd);
			return 0;
		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 string_list split = STRING_LIST_INIT_NODUP;
		string_list_split_in_place_f(&split, buf.buf, " ", -1,
					     STRING_LIST_SPLIT_TRIM);
		if (split.nr < 2)
			die(_("malformed input line: '%s'."), buf.buf);
		if (repo_get_oid(the_repository, split.items[0].string, &from_obj))
			die(_("failed to resolve '%s' as a valid ref."),
			    split.items[0].string);
		if (repo_get_oid(the_repository, split.items[1].string, &to_obj))
			die(_("failed to resolve '%s' as a valid ref."),
			    split.items[1].string);
		if (rewrite_cmd)
			err = copy_note_for_rewrite(c, &from_obj, &to_obj);
			err = copy_note(t, &from_obj, &to_obj, force,
					combine_notes_overwrite);
		if (err) {
			error(_("failed to copy notes from '%s' to '%s'"),
			      split.items[0].string, split.items[1].string);
			ret = 1;
		string_list_clear(&split, 0);
	if (!rewrite_cmd) {
		commit_notes(the_repository, t, msg);
		free_notes(t);
		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);
static int list(int argc, const char **argv, const char *prefix,
		struct repository *repo UNUSED)
	struct notes_tree *t;
	struct object_id object;
	const struct object_id *note;
	int retval = -1;
	struct option options[] = {
		OPT_END()
		argc = parse_options(argc, argv, prefix, options,
				     git_notes_lis
B94A
t_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 (repo_get_oid(the_repository, 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;
			retval = error(_("no note found for object %s."),
				       oid_to_hex(&object));
		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,
		       struct repository *repo UNUSED);
static int add(int argc, const char **argv, const char *prefix,
	       struct repository *repo)
	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 = { .buf = STRBUF_INIT, .stripspace = UNSPECIFIED };
	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_BOOL('e', "edit", &d.use_editor,
			N_("edit note message in editor")),
		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_CALLBACK_F(0, "separator", &separator,
			N_("<paragraph-break>"),
			N_("insert <paragraph-break> between paragraphs"),
			PARSE_OPT_OPTARG, parse_separator_arg),
		OPT_BOOL(0, "stripspace", &d.stripspace,
			N_("remove unnecessary whitespace")),
		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);
	if (d.msg_nr)
		concat_messages(&d);
	object_ref = argc > 1 ? argv[1] : "HEAD";
	if (repo_get_oid(the_repository, 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.msg_nr) {
				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, repo);
		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'");
		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);
static int copy(int argc, const char **argv, const char *prefix,
		struct repository *repo UNUSED)
	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 <command> (implies "
			      "--stdin)")),
		OPT_END()
	argc = parse_options(argc, argv, prefix, options, git_notes_copy_usage,
	if (from_stdin || rewrite_cmd) {
		if (argc) {
			error(_("too many arguments"));
			usage_with_options(git_notes_copy_usage, options);
			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 (repo_get_oid(the_repository, argv[0], &from_obj))
		die(_("failed to resolve '%s' as a valid ref."), argv[0]);
	object_ref = 1 < argc ? argv[1] : "HEAD";
	if (repo_get_oid(the_repository, 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'");
	free_notes(t);
	return retval;
static int append_edit(int argc, const char **argv, const char *prefix,
		       struct repository *repo UNUSED)
	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 = { .buf = STRBUF_INIT, .stripspace = UNSPECIFIED };
	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('e', "edit", &d.use_editor,
			N_("edit note message in editor")),
		OPT_BOOL(0, "allow-empty", &allow_empty,
			N_("allow storing empty note")),
		OPT_CALLBACK_F(0, "separator", &separator,
			N_("<paragraph-break>"),
			N_("insert <paragraph-break> between paragraphs"),
			PARSE_OPT_OPTARG, parse_separator_arg),
		OPT_BOOL(0, "stripspace", &d.stripspace,
			N_("remove unnecessary whitespace")),
		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.msg_nr) {
		concat_messages(&d);
		if (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 (repo_get_oid(the_repository, 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;
		struct strbuf buf = STRBUF_INIT;
		char *prev_buf = odb_read_object(the_repository->objects, note, &type, &size);
		if (!prev_buf)
			die(_("unable to read %s"), oid_to_hex(note));
		if (size)
			strbuf_add(&buf, prev_buf, size);
		if (d.buf.len && size)
			append_separator(&buf);
		strbuf_insert(&d.buf, 0, buf.buf, buf.len);
		free(prev_buf);
		strbuf_release(&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]);
		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);
static int show(int argc, const char **argv, const char *prefix,
		struct repository *repo UNUSED)
	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,
	if (1 < argc) {
		error(_("too many arguments"));
		usage_with_options(git_notes_show_usage, options);
	object_ref = argc ? argv[0] : "HEAD";
	if (repo_get_oid(the_repository, 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));
		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 (refs_delete_ref(get_main_ref_store(the_repository), NULL, "NOTES_MERGE_PARTIAL", NULL, 0))
		ret += error(_("failed to delete ref NOTES_MERGE_PARTIAL"));
	if (refs_delete_ref(get_main_ref_store(the_repository), 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 = {0};
	struct commit *partial;
	struct pretty_print_context pretty_ctx;
	void *local_ref_to_free;
	 * Read partial merge result from .git/NOTES_MERGE_PARTIAL,
	 * and target notes ref from .git/NOTES_MERGE_REF.
	if (repo_get_oid(the_repository, "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 (repo_parse_commit(the_repository, partial))
		die(_("could not parse commit from NOTES_MERGE_PARTIAL."));
	if (partial->parents)
		oidcpy(&parent_oid, &partial->parents->item->object.oid);
		oidclr(&parent_oid, the_repository->hash_algo);
	init_notes(&t, "NOTES_MERGE_PARTIAL", combine_notes_overwrite, 0);
	o->local_ref = local_ref_to_free =
		refs_resolve_refdup(get_main_ref_store(the_repository),
				    "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));
	repo_format_commit_message(the_repository, partial, "%s", &msg,
				   &pretty_ctx);
	strbuf_trim(&msg);
	strbuf_insertstr(&msg, 0, "notes: ");
	refs_update_ref(get_main_ref_store(the_repository), 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 (repo_config_get_string(the_repository, key, &value))
		return 1;
	if (parse_notes_merge_strategy(value, strategy))
		git_die_config(the_repository, key, _("unknown notes merge strategy %s"), value);
	free(value);
static int merge(int argc, const char **argv, const char *prefix,
		 struct repository *repo UNUSED)
	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()
	char *notes_ref;
	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);
	notes_ref = default_notes_ref(the_repository);
	o.local_ref = 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);
		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, 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 */
		refs_update_ref(get_main_ref_store(the_repository), msg.buf,
				notes_ref, &result_oid, NULL, 0,
				UPDATE_REFS_DIE_ON_ERR);
	else { /* Merge has unresolved conflicts */
		struct worktree **worktrees;
		const struct worktree *wt;
		char *path;
		/* Update .git/NOTES_MERGE_PARTIAL with partial merge result */
		refs_update_ref(get_main_ref_store(the_repository), 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",
					notes_ref);
			die(_("a notes merge into %s is already in-progress at %s"),
			    notes_ref, wt->path);
		free_worktrees(worktrees);
		if (refs_update_symref(get_main_ref_store(the_repository), "NOTES_MERGE_REF", notes_ref, NULL))
			die(_("failed to store link to current notes ref (%s)"),
View remainder of file in raw view
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

notes.c

Latest commit

History

notes.c

File metadata and controls
