Builtin-ify git-notes

The builtin-ification includes some minor behavioural changes to the
command-line interface: It is no longer allowed to mix the -m and -F
arguments, and it is not allowed to use multiple -F options.

As part of the builtin-ification, we add the commit_notes() function
to the builtin API. This function (together with the notes.h API) can
be easily used from other builtins to manipulate the notes tree.

Also includes needed changes to t3301.

This patch has been improved by the following contributions:
- Stephen Boyd: Use die() instead of fprintf(stderr, ...) followed by exit(1)

Cc: Stephen Boyd <bebarino@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/Documentation/git-notes.txt b/Documentation/git-notes.txt
index d4487cab5284670644f88d95680581ffd29ae952..0d1ada6a0ced4ad0d1df8e32b34eedc7d463547d 100644 (file)
--- a/Documentation/git-notes.txt
+++ b/Documentation/git-notes.txt
@@ -37,14 +37,12 @@ OPTIONS
 -------
 -m <msg>::
        Use the given note message (instead of prompting).
-       If multiple `-m` (or `-F`) options are given, their
-       values are concatenated as separate paragraphs.
+       If multiple `-m` options are given, their values
+       are concatenated as separate paragraphs.
 
 -F <file>::
        Take the note message from the given file.  Use '-' to
        read the note message from the standard input.
-       If multiple `-F` (or `-m`) options are given, their
-       values are concatenated as separate paragraphs.
 
 
 Author

diff --git a/Makefile b/Makefile
index c0dbee2ae40823b4e8433891a704f94eaaf6d525..1f95f93f76d5e098cde7015398fcad9ce69d9ab8 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -353,7 +353,6 @@ SCRIPT_SH += git-merge-one-file.sh
 SCRIPT_SH += git-merge-resolve.sh
 SCRIPT_SH += git-mergetool.sh
 SCRIPT_SH += git-mergetool--lib.sh
-SCRIPT_SH += git-notes.sh
 SCRIPT_SH += git-parse-remote.sh
 SCRIPT_SH += git-pull.sh
 SCRIPT_SH += git-quiltimport.sh
@@ -671,6 +670,7 @@ BUILTIN_OBJS += builtin-mktag.o
 BUILTIN_OBJS += builtin-mktree.o
 BUILTIN_OBJS += builtin-mv.o
 BUILTIN_OBJS += builtin-name-rev.o
+BUILTIN_OBJS += builtin-notes.o
 BUILTIN_OBJS += builtin-pack-objects.o
 BUILTIN_OBJS += builtin-pack-redundant.o
 BUILTIN_OBJS += builtin-pack-refs.o

diff --git a/builtin-notes.c b/builtin-notes.c
new file mode 100644 (file)
index 0000000..89aa6e0
--- /dev/null
+++ b/builtin-notes.c
@@ -0,0 +1,280 @@
+/*
+ * 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.
+ */
+
+#include "cache.h"
+#include "builtin.h"
+#include "notes.h"
+#include "blob.h"
+#include "commit.h"
+#include "refs.h"
+#include "exec_cmd.h"
+#include "run-command.h"
+#include "parse-options.h"
+
+static const char * const git_notes_usage[] = {
+       "git notes edit [-m <msg> | -F <file>] [<object>]",
+       "git notes show [<object>]",
+       NULL
+};
+
+static const char note_template[] =
+       "\n"
+       "#\n"
+       "# Write/edit the notes for the following object:\n"
+       "#\n";
+
+static void write_note_data(int fd, const unsigned char *sha1)
+{
+       unsigned long size;
+       enum object_type type;
+       char *buf = read_sha1_file(sha1, &type, &size);
+       if (buf) {
+               if (size)
+                       write_or_die(fd, buf, size);
+               free(buf);
+       }
+}
+
+static void write_commented_object(int fd, const unsigned char *object)
+{
+       const char *show_args[5] =
+               {"show", "--stat", "--no-notes", sha1_to_hex(object), NULL};
+       struct child_process show;
+       struct strbuf buf = STRBUF_INIT;
+       FILE *show_out;
+
+       /* Invoke "git show --stat --no-notes $object" */
+       memset(&show, 0, sizeof(show));
+       show.argv = show_args;
+       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'",
+                   sha1_to_hex(object));
+
+       /* Open the output as FILE* so strbuf_getline() can be used. */
+       show_out = xfdopen(show.out, "r");
+       if (show_out == NULL)
+               die_errno("can't fdopen 'show' output fd");
+
+       /* Prepend "# " to each output line and write result to 'fd' */
+       while (strbuf_getline(&buf, show_out, '\n') != EOF) {
+               write_or_die(fd, "# ", 2);
+               write_or_die(fd, buf.buf, buf.len);
+               write_or_die(fd, "\n", 1);
+       }
+       strbuf_release(&buf);
+       if (fclose(show_out))
+               die_errno("failed to close pipe to 'show' for object '%s'",
+                         sha1_to_hex(object));
+       if (finish_command(&show))
+               die("failed to finish 'show' for object '%s'",
+                   sha1_to_hex(object));
+}
+
+static void create_note(const unsigned char *object,
+                       struct strbuf *buf,
+                       int skip_editor,
+                       const unsigned char *prev,
+                       unsigned char *result)
+{
+       char *path = NULL;
+
+       if (!skip_editor) {
+               int fd;
+
+               /* write the template message before editing: */
+               path = git_pathdup("NOTES_EDITMSG");
+               fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0600);
+               if (fd < 0)
+                       die_errno("could not create file '%s'", path);
+
+               if (prev)
+                       write_note_data(fd, prev);
+               write_or_die(fd, note_template, strlen(note_template));
+
+               write_commented_object(fd, object);
+
+               close(fd);
+
+               if (launch_editor(path, buf, NULL)) {
+                       die("Please supply the note contents using either -m" \
+                           " or -F option");
+               }
+       }
+
+       stripspace(buf, 1);
+
+       if (!skip_editor && !buf->len) {
+               fprintf(stderr, "Removing note for object %s\n",
+                       sha1_to_hex(object));
+               hashclr(result);
+       } else {
+               if (write_sha1_file(buf->buf, buf->len, blob_type, result)) {
+                       error("unable to write note object");
+                       if (path)
+                               error("The note contents has been left in %s",
+                                     path);
+                       exit(128);
+               }
+       }
+
+       if (path) {
+               unlink_or_warn(path);
+               free(path);
+       }
+}
+
+struct msg_arg {
+       int given;
+       struct strbuf buf;
+};
+
+static int parse_msg_arg(const struct option *opt, const char *arg, int unset)
+{
+       struct msg_arg *msg = opt->value;
+
+       if (!arg)
+               return -1;
+       if (msg->buf.len)
+               strbuf_addstr(&(msg->buf), "\n\n");
+       strbuf_addstr(&(msg->buf), arg);
+       msg->given = 1;
+       return 0;
+}
+
+int commit_notes(struct notes_tree *t, const char *msg)
+{
+       struct commit_list *parent;
+       unsigned char tree_sha1[20], prev_commit[20], new_commit[20];
+       struct strbuf buf = STRBUF_INIT;
+
+       if (!t)
+               t = &default_notes_tree;
+       if (!t->initialized || !t->ref || !*t->ref)
+               die("Cannot commit uninitialized/unreferenced notes tree");
+
+       /* Prepare commit message and reflog message */
+       strbuf_addstr(&buf, "notes: "); /* commit message starts at index 7 */
+       strbuf_addstr(&buf, msg);
+       if (buf.buf[buf.len - 1] != '\n')
+               strbuf_addch(&buf, '\n'); /* Make sure msg ends with newline */
+
+       /* Convert notes tree to tree object */
+       if (write_notes_tree(t, tree_sha1))
+               die("Failed to write current notes tree to database");
+
+       /* Create new commit for the tree object */
+       if (!read_ref(t->ref, prev_commit)) { /* retrieve parent commit */
+               parent = xmalloc(sizeof(*parent));
+               parent->item = lookup_commit(prev_commit);
+               parent->next = NULL;
+       } else {
+               hashclr(prev_commit);
+               parent = NULL;
+       }
+       if (commit_tree(buf.buf + 7, tree_sha1, parent, new_commit, NULL))
+               die("Failed to commit notes tree to database");
+
+       /* Update notes ref with new commit */
+       update_ref(buf.buf, t->ref, new_commit, prev_commit, 0, DIE_ON_ERR);
+
+       strbuf_release(&buf);
+       return 0;
+}
+
+int cmd_notes(int argc, const char **argv, const char *prefix)
+{
+       struct strbuf buf = STRBUF_INIT;
+       struct notes_tree *t;
+       unsigned char object[20], new_note[20];
+       const unsigned char *note;
+       const char *object_ref;
+       int edit = 0, show = 0;
+       const char *msgfile = NULL;
+       struct msg_arg msg = { 0, STRBUF_INIT };
+       struct option options[] = {
+               OPT_GROUP("Notes edit options"),
+               OPT_CALLBACK('m', NULL, &msg, "msg",
+                            "note contents as a string", parse_msg_arg),
+               OPT_FILENAME('F', NULL, &msgfile, "note contents in a file"),
+               OPT_END()
+       };
+
+       git_config(git_default_config, NULL);
+
+       argc = parse_options(argc, argv, prefix, options, git_notes_usage, 0);
+
+       if (argc && !strcmp(argv[0], "edit"))
+               edit = 1;
+       else if (argc && !strcmp(argv[0], "show"))
+               show = 1;
+
+       if (edit + show != 1)
+               usage_with_options(git_notes_usage, options);
+
+       object_ref = argc == 2 ? argv[1] : "HEAD";
+       if (argc > 2) {
+               error("too many parameters");
+               usage_with_options(git_notes_usage, options);
+       }
+
+       if (get_sha1(object_ref, object))
+               die("Failed to resolve '%s' as a valid ref.", object_ref);
+
+       init_notes(NULL, NULL, NULL, 0);
+       t = &default_notes_tree;
+
+       if (prefixcmp(t->ref, "refs/notes/"))
+               die("Refusing to %s notes in %s (outside of refs/notes/)",
+                   edit ? "edit" : "show", t->ref);
+
+       note = get_note(t, object);
+
+       /* show command */
+
+       if (show && !note) {
+               error("No note found for object %s.", sha1_to_hex(object));
+               return 1;
+       } else if (show) {
+               const char *show_args[3] = {"show", sha1_to_hex(note), NULL};
+               return execv_git_cmd(show_args);
+       }
+
+       /* edit command */
+
+       if (msg.given || msgfile) {
+               if (msg.given && msgfile) {
+                       error("mixing -m and -F options is not allowed.");
+                       usage_with_options(git_notes_usage, options);
+               }
+               if (msg.given)
+                       strbuf_addbuf(&buf, &(msg.buf));
+               else {
+                       if (!strcmp(msgfile, "-")) {
+                               if (strbuf_read(&buf, 0, 1024) < 0)
+                                       die_errno("cannot read '%s'", msgfile);
+                       } else {
+                               if (strbuf_read_file(&buf, msgfile, 1024) < 0)
+                                       die_errno("could not open or read '%s'",
+                                               msgfile);
+                       }
+               }
+       }
+
+       create_note(object, &buf, msg.given || msgfile, note, new_note);
+       add_note(t, object, new_note, combine_notes_overwrite);
+       commit_notes(t, "Note added by 'git notes edit'");
+
+       free_notes(t);
+       strbuf_release(&buf);
+       return 0;
+}

diff --git a/builtin.h b/builtin.h
index e8202f3f5e57a302634be9268866edaba0fd6eb0..cdf98477a662a32790b55b70c23221141377633e 100644 (file)
--- a/builtin.h
+++ b/builtin.h
@@ -5,6 +5,7 @@
 #include "strbuf.h"
 #include "cache.h"
 #include "commit.h"
+#include "notes.h"
 
 extern const char git_version_string[];
 extern const char git_usage_string[];
@@ -18,6 +19,7 @@ extern int fmt_merge_msg(int merge_summary, struct strbuf *in,
 extern int commit_tree(const char *msg, unsigned char *tree,
                struct commit_list *parents, unsigned char *ret,
                const char *author);
+extern int commit_notes(struct notes_tree *t, const char *msg);
 extern int check_pager_config(const char *cmd);
 
 extern int cmd_add(int argc, const char **argv, const char *prefix);
@@ -78,6 +80,7 @@ extern int cmd_mktag(int argc, const char **argv, const char *prefix);
 extern int cmd_mktree(int argc, const char **argv, const char *prefix);
 extern int cmd_mv(int argc, const char **argv, const char *prefix);
 extern int cmd_name_rev(int argc, const char **argv, const char *prefix);
+extern int cmd_notes(int argc, const char **argv, const char *prefix);
 extern int cmd_pack_objects(int argc, const char **argv, const char *prefix);
 extern int cmd_pack_redundant(int argc, const char **argv, const char *prefix);
 extern int cmd_patch_id(int argc, const char **argv, const char *prefix);

diff --git a/contrib/examples/git-notes.sh b/contrib/examples/git-notes.sh
new file mode 100755 (executable)
index 0000000..e642e47
--- /dev/null
+++ b/contrib/examples/git-notes.sh
@@ -0,0 +1,121 @@
+#!/bin/sh
+
+USAGE="(edit [-F <file> | -m <msg>] | show) [commit]"
+. git-sh-setup
+
+test -z "$1" && usage
+ACTION="$1"; shift
+
+test -z "$GIT_NOTES_REF" && GIT_NOTES_REF="$(git config core.notesref)"
+test -z "$GIT_NOTES_REF" && GIT_NOTES_REF="refs/notes/commits"
+
+MESSAGE=
+while test $# != 0
+do
+       case "$1" in
+       -m)
+               test "$ACTION" = "edit" || usage
+               shift
+               if test "$#" = "0"; then
+                       die "error: option -m needs an argument"
+               else
+                       if [ -z "$MESSAGE" ]; then
+                               MESSAGE="$1"
+                       else
+                               MESSAGE="$MESSAGE
+
+$1"
+                       fi
+                       shift
+               fi
+               ;;
+       -F)
+               test "$ACTION" = "edit" || usage
+               shift
+               if test "$#" = "0"; then
+                       die "error: option -F needs an argument"
+               else
+                       if [ -z "$MESSAGE" ]; then
+                               MESSAGE="$(cat "$1")"
+                       else
+                               MESSAGE="$MESSAGE
+
+$(cat "$1")"
+                       fi
+                       shift
+               fi
+               ;;
+       -*)
+               usage
+               ;;
+       *)
+               break
+               ;;
+       esac
+done
+
+COMMIT=$(git rev-parse --verify --default HEAD "$@") ||
+die "Invalid commit: $@"
+
+case "$ACTION" in
+edit)
+       if [ "${GIT_NOTES_REF#refs/notes/}" = "$GIT_NOTES_REF" ]; then
+               die "Refusing to edit notes in $GIT_NOTES_REF (outside of refs/notes/)"
+       fi
+
+       MSG_FILE="$GIT_DIR/new-notes-$COMMIT"
+       GIT_INDEX_FILE="$MSG_FILE.idx"
+       export GIT_INDEX_FILE
+
+       trap '
+               test -f "$MSG_FILE" && rm "$MSG_FILE"
+               test -f "$GIT_INDEX_FILE" && rm "$GIT_INDEX_FILE"
+       ' 0
+
+       CURRENT_HEAD=$(git show-ref "$GIT_NOTES_REF" | cut -f 1 -d ' ')
+       if [ -z "$CURRENT_HEAD" ]; then
+               PARENT=
+       else
+               PARENT="-p $CURRENT_HEAD"
+               git read-tree "$GIT_NOTES_REF" || die "Could not read index"
+       fi
+
+       if [ -z "$MESSAGE" ]; then
+               GIT_NOTES_REF= git log -1 $COMMIT | sed "s/^/#/" > "$MSG_FILE"
+               if [ ! -z "$CURRENT_HEAD" ]; then
+                       git cat-file blob :$COMMIT >> "$MSG_FILE" 2> /dev/null
+               fi
+               core_editor="$(git config core.editor)"
+               ${GIT_EDITOR:-${core_editor:-${VISUAL:-${EDITOR:-vi}}}} "$MSG_FILE"
+       else
+               echo "$MESSAGE" > "$MSG_FILE"
+       fi
+
+       grep -v ^# < "$MSG_FILE" | git stripspace > "$MSG_FILE".processed
+       mv "$MSG_FILE".processed "$MSG_FILE"
+       if [ -s "$MSG_FILE" ]; then
+               BLOB=$(git hash-object -w "$MSG_FILE") ||
+                       die "Could not write into object database"
+               git update-index --add --cacheinfo 0644 $BLOB $COMMIT ||
+                       die "Could not write index"
+       else
+               test -z "$CURRENT_HEAD" &&
+                       die "Will not initialise with empty tree"
+               git update-index --force-remove $COMMIT ||
+                       die "Could not update index"
+       fi
+
+       TREE=$(git write-tree) || die "Could not write tree"
+       NEW_HEAD=$(echo Annotate $COMMIT | git commit-tree $TREE $PARENT) ||
+               die "Could not annotate"
+       git update-ref -m "Annotate $COMMIT" \
+               "$GIT_NOTES_REF" $NEW_HEAD $CURRENT_HEAD
+;;
+show)
+       git rev-parse -q --verify "$GIT_NOTES_REF":$COMMIT > /dev/null ||
+               die "No note for commit $COMMIT."
+       git show "$GIT_NOTES_REF":$COMMIT
+;;
+*)
+       usage
+esac

diff --git a/git-notes.sh b/git-notes.sh
deleted file mode 100755 (executable)
index e642e47..0000000
--- a/git-notes.sh
+++ /dev/null
@@ -1,121 +0,0 @@
-#!/bin/sh
-
-USAGE="(edit [-F <file> | -m <msg>] | show) [commit]"
-. git-sh-setup
-
-test -z "$1" && usage
-ACTION="$1"; shift
-
-test -z "$GIT_NOTES_REF" && GIT_NOTES_REF="$(git config core.notesref)"
-test -z "$GIT_NOTES_REF" && GIT_NOTES_REF="refs/notes/commits"
-
-MESSAGE=
-while test $# != 0
-do
-       case "$1" in
-       -m)
-               test "$ACTION" = "edit" || usage
-               shift
-               if test "$#" = "0"; then
-                       die "error: option -m needs an argument"
-               else
-                       if [ -z "$MESSAGE" ]; then
-                               MESSAGE="$1"
-                       else
-                               MESSAGE="$MESSAGE
-
-$1"
-                       fi
-                       shift
-               fi
-               ;;
-       -F)
-               test "$ACTION" = "edit" || usage
-               shift
-               if test "$#" = "0"; then
-                       die "error: option -F needs an argument"
-               else
-                       if [ -z "$MESSAGE" ]; then
-                               MESSAGE="$(cat "$1")"
-                       else
-                               MESSAGE="$MESSAGE
-
-$(cat "$1")"
-                       fi
-                       shift
-               fi
-               ;;
-       -*)
-               usage
-               ;;
-       *)
-               break
-               ;;
-       esac
-done
-
-COMMIT=$(git rev-parse --verify --default HEAD "$@") ||
-die "Invalid commit: $@"
-
-case "$ACTION" in
-edit)
-       if [ "${GIT_NOTES_REF#refs/notes/}" = "$GIT_NOTES_REF" ]; then
-               die "Refusing to edit notes in $GIT_NOTES_REF (outside of refs/notes/)"
-       fi
-
-       MSG_FILE="$GIT_DIR/new-notes-$COMMIT"
-       GIT_INDEX_FILE="$MSG_FILE.idx"
-       export GIT_INDEX_FILE
-
-       trap '
-               test -f "$MSG_FILE" && rm "$MSG_FILE"
-               test -f "$GIT_INDEX_FILE" && rm "$GIT_INDEX_FILE"
-       ' 0
-
-       CURRENT_HEAD=$(git show-ref "$GIT_NOTES_REF" | cut -f 1 -d ' ')
-       if [ -z "$CURRENT_HEAD" ]; then
-               PARENT=
-       else
-               PARENT="-p $CURRENT_HEAD"
-               git read-tree "$GIT_NOTES_REF" || die "Could not read index"
-       fi
-
-       if [ -z "$MESSAGE" ]; then
-               GIT_NOTES_REF= git log -1 $COMMIT | sed "s/^/#/" > "$MSG_FILE"
-               if [ ! -z "$CURRENT_HEAD" ]; then
-                       git cat-file blob :$COMMIT >> "$MSG_FILE" 2> /dev/null
-               fi
-               core_editor="$(git config core.editor)"
-               ${GIT_EDITOR:-${core_editor:-${VISUAL:-${EDITOR:-vi}}}} "$MSG_FILE"
-       else
-               echo "$MESSAGE" > "$MSG_FILE"
-       fi
-
-       grep -v ^# < "$MSG_FILE" | git stripspace > "$MSG_FILE".processed
-       mv "$MSG_FILE".processed "$MSG_FILE"
-       if [ -s "$MSG_FILE" ]; then
-               BLOB=$(git hash-object -w "$MSG_FILE") ||
-                       die "Could not write into object database"
-               git update-index --add --cacheinfo 0644 $BLOB $COMMIT ||
-                       die "Could not write index"
-       else
-               test -z "$CURRENT_HEAD" &&
-                       die "Will not initialise with empty tree"
-               git update-index --force-remove $COMMIT ||
-                       die "Could not update index"
-       fi
-
-       TREE=$(git write-tree) || die "Could not write tree"
-       NEW_HEAD=$(echo Annotate $COMMIT | git commit-tree $TREE $PARENT) ||
-               die "Could not annotate"
-       git update-ref -m "Annotate $COMMIT" \
-               "$GIT_NOTES_REF" $NEW_HEAD $CURRENT_HEAD
-;;
-show)
-       git rev-parse -q --verify "$GIT_NOTES_REF":$COMMIT > /dev/null ||
-               die "No note for commit $COMMIT."
-       git show "$GIT_NOTES_REF":$COMMIT
-;;
-*)
-       usage
-esac

diff --git a/git.c b/git.c
index b3e23f10441924de45ab768e086ead90b214d4c7..32f76e15ea732d2d784fb8ee5076801f0b57cce6 100644 (file)
--- a/git.c
+++ b/git.c
@@ -343,6 +343,7 @@ static void handle_internal_command(int argc, const char **argv)
                { "mktree", cmd_mktree, RUN_SETUP },
                { "mv", cmd_mv, RUN_SETUP | NEED_WORK_TREE },
                { "name-rev", cmd_name_rev, RUN_SETUP },
+               { "notes", cmd_notes, RUN_SETUP },
                { "pack-objects", cmd_pack_objects, RUN_SETUP },
                { "pack-redundant", cmd_pack_redundant, RUN_SETUP },
                { "patch-id", cmd_patch_id },

diff --git a/t/t3301-notes.sh b/t/t3301-notes.sh
index 18aad5389913f5a2cfe24c7a25b2679c453ceaf8..10f62f41223af26f0aca2e21db467a7a7fc93010 100755 (executable)
--- a/t/t3301-notes.sh
+++ b/t/t3301-notes.sh
@@ -12,8 +12,8 @@ echo "$MSG" > "$1"
 echo "$MSG" >& 2
 EOF
 chmod a+x fake_editor.sh
-VISUAL=./fake_editor.sh
-export VISUAL
+GIT_EDITOR=./fake_editor.sh
+export GIT_EDITOR
 
 test_expect_success 'cannot annotate non-existing HEAD' '
        (MSG=3 && export MSG && test_must_fail git notes edit)
@@ -56,8 +56,17 @@ test_expect_success 'handle empty notes gracefully' '
 
 test_expect_success 'create notes' '
        git config core.notesRef refs/notes/commits &&
+       MSG=b0 git notes edit &&
+       test ! -f .git/NOTES_EDITMSG &&
+       test 1 = $(git ls-tree refs/notes/commits | wc -l) &&
+       test b0 = $(git notes show) &&
+       git show HEAD^ &&
+       test_must_fail git notes show HEAD^
+'
+
+test_expect_success 'edit existing notes' '
        MSG=b1 git notes edit &&
-       test ! -f .git/new-notes &&
+       test ! -f .git/NOTES_EDITMSG &&
        test 1 = $(git ls-tree refs/notes/commits | wc -l) &&
        test b1 = $(git notes show) &&
        git show HEAD^ &&
@@ -110,19 +119,16 @@ test_expect_success 'show multi-line notes' '
        git log -2 > output &&
        test_cmp expect-multiline output
 '
-test_expect_success 'create -m and -F notes (setup)' '
+test_expect_success 'create -F notes (setup)' '
        : > a4 &&
        git add a4 &&
        test_tick &&
        git commit -m 4th &&
        echo "xyzzy" > note5 &&
-       git notes edit -m spam -F note5 -m "foo
-bar
-baz"
+       git notes edit -F note5
 '
 
-whitespace="    "
-cat > expect-m-and-F << EOF
+cat > expect-F << EOF
 commit 15023535574ded8b1a89052b32673f84cf9582b8
 Author: A U Thor <author@example.com>
 Date:   Thu Apr 7 15:16:13 2005 -0700
@@ -130,21 +136,15 @@ Date:   Thu Apr 7 15:16:13 2005 -0700
     4th
 
 Notes:
-    spam
-$whitespace
     xyzzy
-$whitespace
-    foo
-    bar
-    baz
 EOF
 
-printf "\n" >> expect-m-and-F
-cat expect-multiline >> expect-m-and-F
+printf "\n" >> expect-F
+cat expect-multiline >> expect-F
 
-test_expect_success 'show -m and -F notes' '
+test_expect_success 'show -F notes' '
        git log -3 > output &&
-       test_cmp expect-m-and-F output
+       test_cmp expect-F output
 '
 
 cat >expect << EOF
@@ -164,13 +164,7 @@ test_expect_success 'git log --pretty=raw does not show notes' '
 cat >>expect <<EOF
 
 Notes:
-    spam
-$whitespace
     xyzzy
-$whitespace
-    foo
-    bar
-    baz
 EOF
 test_expect_success 'git log --show-notes' '
        git log -1 --pretty=raw --show-notes >output &&
@@ -179,17 +173,17 @@ test_expect_success 'git log --show-notes' '
 
 test_expect_success 'git log --no-notes' '
        git log -1 --no-notes >output &&
-       ! grep spam output
+       ! grep xyzzy output
 '
 
 test_expect_success 'git format-patch does not show notes' '
        git format-patch -1 --stdout >output &&
-       ! grep spam output
+       ! grep xyzzy output
 '
 
 test_expect_success 'git format-patch --show-notes does show notes' '
        git format-patch --show-notes -1 --stdout >output &&
-       grep spam output
+       grep xyzzy output
 '
 
 for pretty in \
@@ -202,35 +196,69 @@ do
        esac
        test_expect_success "git show $pretty does$not show notes" '
                git show $p >output &&
-               eval "$negate grep spam output"
+               eval "$negate grep xyzzy output"
        '
 done
 
-test_expect_success 'create other note on a different notes ref (setup)' '
+test_expect_success 'create -m notes (setup)' '
        : > a5 &&
        git add a5 &&
        test_tick &&
        git commit -m 5th &&
-       GIT_NOTES_REF="refs/notes/other" git notes edit -m "other note"
+       git notes edit -m spam -m "foo
+bar
+baz"
 '
 
-cat > expect-other << EOF
+whitespace="    "
+cat > expect-m << EOF
 commit bd1753200303d0a0344be813e504253b3d98e74d
 Author: A U Thor <author@example.com>
 Date:   Thu Apr 7 15:17:13 2005 -0700
 
     5th
 
+Notes:
+    spam
+$whitespace
+    foo
+    bar
+    baz
+EOF
+
+printf "\n" >> expect-m
+cat expect-F >> expect-m
+
+test_expect_success 'show -m notes' '
+       git log -4 > output &&
+       test_cmp expect-m output
+'
+
+test_expect_success 'create other note on a different notes ref (setup)' '
+       : > a6 &&
+       git add a6 &&
+       test_tick &&
+       git commit -m 6th &&
+       GIT_NOTES_REF="refs/notes/other" git notes edit -m "other note"
+'
+
+cat > expect-other << EOF
+commit 387a89921c73d7ed72cd94d179c1c7048ca47756
+Author: A U Thor <author@example.com>
+Date:   Thu Apr 7 15:18:13 2005 -0700
+
+    6th
+
 Notes:
     other note
 EOF
 
 cat > expect-not-other << EOF
-commit bd1753200303d0a0344be813e504253b3d98e74d
+commit 387a89921c73d7ed72cd94d179c1c7048ca47756
 Author: A U Thor <author@example.com>
-Date:   Thu Apr 7 15:17:13 2005 -0700
+Date:   Thu Apr 7 15:18:13 2005 -0700
 
-    5th
+    6th
 EOF
 
 test_expect_success 'Do not show note on other ref by default' '