thodg/libgit2

diff --git a/include/git2/notes.h b/include/git2/notes.h
index 3a626ca..853e5de 100644
--- a/include/git2/notes.h
+++ b/include/git2/notes.h
@@ -52,6 +52,20 @@ GIT_EXTERN(int) git_note_iterator_new(
 	const char *notes_ref);
 
 /**
+ * Creates a new iterator for notes from a commit
+ *
+ * The iterator must be freed manually by the user.
+ *
+ * @param out pointer to the iterator
+ * @param notes_commit a pointer to the notes commit object
+ *
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_note_commit_iterator_new(
+	git_note_iterator **out,
+	git_commit *notes_commit);
+
+/**
  * Frees an git_note_iterator
  *
  * @param it pointer to the iterator
@@ -94,6 +108,25 @@ GIT_EXTERN(int) git_note_read(
 	const char *notes_ref,
 	const git_oid *oid);
 
+
+/**
+ * Read the note for an object from a note commit
+ *
+ * The note must be freed manually by the user.
+ *
+ * @param out pointer to the read note; NULL in case of error
+ * @param repo repository where to look up the note
+ * @param notes_commit a pointer to the notes commit object
+ * @param oid OID of the git object to read the note from
+ *
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_note_commit_read(
+	git_note **out,
+	git_repository *repo,
+	git_commit *notes_commit,
+	const git_oid *oid);
+
 /**
  * Get the note author
  *
@@ -153,6 +186,36 @@ GIT_EXTERN(int) git_note_create(
 	const char *note,
 	int force);
 
+/**
+ * Add a note for an object from a commit
+ *
+ * This function will create a notes commit for a given object,
+ * the commit is a dangling commit, no reference is created.
+ *
+ * @param notes_commit_out pointer to store the commit (optional);
+ *					NULL in case of error
+ * @param notes_blob_out a point to the id of a note blob (optional)
+ * @param repo repository where the note will live
+ * @param parent Pointer to parent note
+ *					or NULL if this shall start a new notes tree
+ * @param author signature of the notes commit author
+ * @param committer signature of the notes commit committer
+ * @param oid OID of the git object to decorate
+ * @param note Content of the note to add for object oid
+ * @param allow_note_overwrite Overwrite existing note
+ *
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_note_commit_create(
+	git_oid *notes_commit_out,
+	git_oid *notes_blob_out,
+	git_repository *repo,
+	git_commit *parent,
+	const git_signature *author,
+	const git_signature *committer,
+	const git_oid *oid,
+	const char *note,
+	int allow_note_overwrite);
 
 /**
  * Remove the note for an object
@@ -174,6 +237,32 @@ GIT_EXTERN(int) git_note_remove(
 	const git_oid *oid);
 
 /**
+ * Remove the note for an object
+ *
+ * @param notes_commit_out pointer to store the new notes commit (optional);
+ *					NULL in case of error.
+ *					When removing a note a new tree containing all notes
+ *					sans the note to be removed is created and a new commit
+ *					pointing to that tree is also created.
+ *					In the case where the resulting tree is an empty tree
+ *					a new commit pointing to this empty tree will be returned.
+ * @param repo repository where the note lives
+ * @param notes_commit a pointer to the notes commit object
+ * @param author signature of the notes commit author
+ * @param committer signature of the notes commit committer
+ * @param oid OID of the git object to remove the note from
+ *
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_note_commit_remove(
+		git_oid *notes_commit_out,
+		git_repository *repo,
+		git_commit *notes_commit,
+		const git_signature *author,
+		const git_signature *committer,
+		const git_oid *oid);
+
+/**
  * Free a git_note object
  *
  * @param note git_note object
diff --git a/src/notes.c b/src/notes.c
index 75108b9..f63ef36 100644
--- a/src/notes.c
+++ b/src/notes.c
@@ -268,7 +268,9 @@ static int insert_note_in_tree_enotfound_cb(git_tree **out,
 		GIT_FILEMODE_BLOB);
 }
 
-static int note_write(git_oid *out,
+static int note_write(
+	git_oid *notes_commit_out,
+	git_oid *notes_blob_out,
 	git_repository *repo,
 	const git_signature *author,
 	const git_signature *committer,
@@ -294,13 +296,17 @@ static int note_write(git_oid *out,
 		insert_note_in_tree_enotfound_cb)) < 0)
 		goto cleanup;
 
-	if (out)
-		git_oid_cpy(out, &oid);
+	if (notes_blob_out)
+		git_oid_cpy(notes_blob_out, &oid);
+
 
 	error = git_commit_create(&oid, repo, notes_ref, author, committer,
 				  NULL, GIT_NOTES_DEFAULT_MSG_ADD,
 				  tree, *parents == NULL ? 0 : 1, (const git_commit **) parents);
 
+	if (notes_commit_out)
+		git_oid_cpy(notes_commit_out, &oid);
+
 cleanup:
 	git_tree_free(tree);
 	return error;
@@ -363,7 +369,9 @@ cleanup:
 	return error;
 }
 
-static int note_remove(git_repository *repo,
+static int note_remove(
+		git_oid *notes_commit_out,
+		git_repository *repo,
 		const git_signature *author, const git_signature *committer,
 		const char *notes_ref, git_tree *tree,
 		const char *target, git_commit **parents)
@@ -383,6 +391,12 @@ static int note_remove(git_repository *repo,
 	  *parents == NULL ? 0 : 1,
 	  (const git_commit **) parents);
 
+	if (error < 0)
+		goto cleanup;
+
+	if (notes_commit_out)
+		git_oid_cpy(notes_commit_out, &oid);
+
 cleanup:
 	git_tree_free(tree_after_removal);
 	return error;
@@ -410,8 +424,7 @@ static int normalize_namespace(char **out, git_repository *repo, const char *not
 	return note_get_default_ref(out, repo);
 }
 
-static int retrieve_note_tree_and_commit(
-	git_tree **tree_out,
+static int retrieve_note_commit(
 	git_commit **commit_out,
 	char **notes_ref_out,
 	git_repository *repo,
@@ -429,34 +442,82 @@ static int retrieve_note_tree_and_commit(
 	if (git_commit_lookup(commit_out, repo, &oid) < 0)
 		return error;
 
-	if ((error = git_commit_tree(tree_out, *commit_out)) < 0)
-		return error;
-
 	return 0;
 }
 
+int git_note_commit_read(
+	git_note **out,
+	git_repository *repo,
+	git_commit *notes_commit,
+	const git_oid *oid)
+{
+	int error;
+	git_tree *tree = NULL;
+	char target[GIT_OID_HEXSZ + 1];
+
+	git_oid_tostr(target, sizeof(target), oid);
+
+	if ((error = git_commit_tree(&tree, notes_commit)) < 0)
+		goto cleanup;
+
+	error = note_lookup(out, repo, notes_commit, tree, target);
+
+cleanup:
+	git_tree_free(tree);
+	return error;
+}
+
 int git_note_read(git_note **out, git_repository *repo,
 		  const char *notes_ref_in, const git_oid *oid)
 {
 	int error;
-	char *target = NULL, *notes_ref = NULL;
-	git_tree *tree = NULL;
+	char *notes_ref = NULL;
 	git_commit *commit = NULL;
 
-	target = git_oid_allocfmt(oid);
-	GITERR_CHECK_ALLOC(target);
+	error = retrieve_note_commit(&commit, &notes_ref, repo, notes_ref_in);
 
-	if (!(error = retrieve_note_tree_and_commit(
-		      &tree, &commit, &notes_ref, repo, notes_ref_in)))
-		error = note_lookup(out, repo, commit, tree, target);
+	if (error < 0)
+		goto cleanup;
 
+	error = git_note_commit_read(out, repo, commit, oid);
+
+cleanup:
 	git__free(notes_ref);
-	git__free(target);
-	git_tree_free(tree);
 	git_commit_free(commit);
 	return error;
 }
 
+int git_note_commit_create(
+	git_oid *notes_commit_out,
+	git_oid *notes_blob_out,
+	git_repository *repo,
+	git_commit *parent,
+	const git_signature *author,
+	const git_signature *committer,
+	const git_oid *oid,
+	const char *note,
+	int allow_note_overwrite)
+{
+	int error;
+	git_tree *tree = NULL;
+	char target[GIT_OID_HEXSZ + 1];
+
+	git_oid_tostr(target, sizeof(target), oid);
+
+	if (parent != NULL && (error = git_commit_tree(&tree, parent)) < 0)
+		goto cleanup;
+
+	error = note_write(notes_commit_out, notes_blob_out, repo, author,
+			committer, NULL, note, tree, target, &parent, allow_note_overwrite);
+
+	if (error < 0)
+		goto cleanup;
+
+cleanup:
+	git_tree_free(tree);
+	return error;
+}
+
 int git_note_create(
 	git_oid *out,
 	git_repository *repo,
@@ -468,25 +529,59 @@ int git_note_create(
 	int allow_note_overwrite)
 {
 	int error;
-	char *target = NULL, *notes_ref = NULL;
-	git_commit *commit = NULL;
-	git_tree *tree = NULL;
-
-	target = git_oid_allocfmt(oid);
-	GITERR_CHECK_ALLOC(target);
+	char *notes_ref = NULL;
+	git_commit *existing_notes_commit = NULL;
+	git_reference *ref = NULL;
+	git_oid notes_blob_oid, notes_commit_oid;
 
-	error = retrieve_note_tree_and_commit(&tree, &commit, &notes_ref, repo, notes_ref_in);
+	error = retrieve_note_commit(&existing_notes_commit, &notes_ref,
+			repo, notes_ref_in);
 
 	if (error < 0 && error != GIT_ENOTFOUND)
 		goto cleanup;
 
-	error = note_write(out, repo, author, committer, notes_ref,
-			note, tree, target, &commit, allow_note_overwrite);
+	error = git_note_commit_create(&notes_commit_oid,
+			&notes_blob_oid,
+			repo, existing_notes_commit, author,
+			committer, oid, note,
+			allow_note_overwrite);
+	if (error < 0)
+		goto cleanup;
+
+	error = git_reference_create(&ref, repo, notes_ref,
+				&notes_commit_oid, 1, NULL);
+
+	if (out != NULL)
+		git_oid_cpy(out, &notes_blob_oid);
 
 cleanup:
 	git__free(notes_ref);
-	git__free(target);
-	git_commit_free(commit);
+	git_commit_free(existing_notes_commit);
+	git_reference_free(ref);
+	return error;
+}
+
+int git_note_commit_remove(
+		git_oid *notes_commit_out,
+		git_repository *repo,
+		git_commit *notes_commit,
+		const git_signature *author,
+		const git_signature *committer,
+		const git_oid *oid)
+{
+	int error;
+	git_tree *tree = NULL;
+	char target[GIT_OID_HEXSZ + 1];
+
+	git_oid_tostr(target, sizeof(target), oid);
+
+	if ((error = git_commit_tree(&tree, notes_commit)) < 0)
+		goto cleanup;
+
+	error = note_remove(notes_commit_out,
+		repo, author, committer, NULL, tree, target, &notes_commit);
+
+cleanup:
 	git_tree_free(tree);
 	return error;
 }
@@ -496,22 +591,29 @@ int git_note_remove(git_repository *repo, const char *notes_ref_in,
 		const git_oid *oid)
 {
 	int error;
-	char *target = NULL, *notes_ref;
-	git_commit *commit = NULL;
-	git_tree *tree = NULL;
+	char *notes_ref_target = NULL;
+	git_commit *existing_notes_commit = NULL;
+	git_oid new_notes_commit;
+	git_reference *notes_ref = NULL;
 
-	target = git_oid_allocfmt(oid);
-	GITERR_CHECK_ALLOC(target);
+	error = retrieve_note_commit(&existing_notes_commit, &notes_ref_target,
+			repo, notes_ref_in);
 
-	if (!(error = retrieve_note_tree_and_commit(
-		      &tree, &commit, &notes_ref, repo, notes_ref_in)))
-		error = note_remove(
-			repo, author, committer, notes_ref, tree, target, &commit);
+	if (error < 0)
+		goto cleanup;
 
-	git__free(notes_ref);
-	git__free(target);
-	git_commit_free(commit);
-	git_tree_free(tree);
+	error = git_note_commit_remove(&new_notes_commit, repo,
+			existing_notes_commit, author, committer, oid);
+	if (error < 0)
+		goto cleanup;
+
+	error = git_reference_create(&notes_ref, repo, notes_ref_target,
+			&new_notes_commit, 1, NULL);
+
+cleanup:
+	git__free(notes_ref_target);
+	git_reference_free(notes_ref);
+	git_commit_free(existing_notes_commit);
 	return error;
 }
 
@@ -639,7 +741,6 @@ int git_note_foreach(
 	return error;
 }
 
-
 void git_note_iterator_free(git_note_iterator *it)
 {
 	if (it == NULL)
@@ -648,6 +749,24 @@ void git_note_iterator_free(git_note_iterator *it)
 	git_iterator_free(it);
 }
 
+int git_note_commit_iterator_new(
+	git_note_iterator **it,
+	git_commit *notes_commit)
+{
+	int error;
+	git_tree *tree;
+
+	if ((error = git_commit_tree(&tree, notes_commit)) < 0)
+		goto cleanup;
+
+	if ((error = git_iterator_for_tree(it, tree, NULL)) < 0)
+		git_iterator_free(*it);
+
+cleanup:
+	git_tree_free(tree);
+
+	return error;
+}
 
 int git_note_iterator_new(
 	git_note_iterator **it,
@@ -656,19 +775,16 @@ int git_note_iterator_new(
 {
 	int error;
 	git_commit *commit = NULL;
-	git_tree *tree = NULL;
 	char *notes_ref;
 
-	error = retrieve_note_tree_and_commit(&tree, &commit, &notes_ref, repo, notes_ref_in);
+	error = retrieve_note_commit(&commit, &notes_ref, repo, notes_ref_in);
 	if (error < 0)
 		goto cleanup;
 
-	if ((error = git_iterator_for_tree(it, tree, NULL)) < 0)
-		git_iterator_free(*it);
+	error = git_note_commit_iterator_new(it, commit);
 
 cleanup:
 	git__free(notes_ref);
-	git_tree_free(tree);
 	git_commit_free(commit);
 
 	return error;
diff --git a/tests/notes/notes.c b/tests/notes/notes.c
index a91bf5b..9626f53 100644
--- a/tests/notes/notes.c
+++ b/tests/notes/notes.c
@@ -73,6 +73,128 @@ static int note_list_cb(
 	return 0;
 }
 
+struct note_create_payload {
+	const char *note_oid;
+	const char *object_oid;
+	unsigned seen;
+};
+
+static int note_list_create_cb(
+	const git_oid *blob_oid, const git_oid *annotated_obj_id, void *payload)
+{
+	git_oid expected_note_oid, expected_target_oid;
+	struct note_create_payload *notes = payload;
+	size_t i;
+
+	for (i = 0; notes[i].note_oid != NULL; i++) {
+		cl_git_pass(git_oid_fromstr(&expected_note_oid, notes[i].note_oid));
+
+		if (git_oid_cmp(&expected_note_oid, blob_oid) != 0)
+			continue;
+
+		cl_git_pass(git_oid_fromstr(&expected_target_oid, notes[i].object_oid));
+
+		if (git_oid_cmp(&expected_target_oid, annotated_obj_id) != 0)
+			continue;
+
+		notes[i].seen = 1;
+		return 0;
+	}
+
+	cl_fail("Did not see expected note");
+	return 0;
+}
+
+void assert_notes_seen(struct note_create_payload payload[], size_t n)
+{
+	size_t seen = 0, i;
+
+	for (i = 0; payload[i].note_oid != NULL; i++) {
+		if (payload[i].seen)
+			seen++;
+	}
+
+	cl_assert_equal_i(seen, n);
+}
+
+void test_notes_notes__can_create_a_note(void)
+{
+	git_oid note_oid;
+	static struct note_create_payload can_create_a_note[] = {
+		{ "1c9b1bc36730582a42d56eeee0dc58673d7ae869", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", 0 },
+		{ NULL, NULL, 0 }
+	};
+
+	create_note(&note_oid, "refs/notes/i-can-see-dead-notes", can_create_a_note[0].object_oid, "I decorate 4a20\n");
+
+	cl_git_pass(git_note_foreach(_repo, "refs/notes/i-can-see-dead-notes", note_list_create_cb, &can_create_a_note));
+
+	assert_notes_seen(can_create_a_note, 1);
+}
+
+void test_notes_notes__can_create_a_note_from_commit(void)
+{
+	git_oid oid;
+	git_oid notes_commit_out;
+	git_reference *ref;
+	static struct note_create_payload can_create_a_note_from_commit[] = {
+		{ "1c9b1bc36730582a42d56eeee0dc58673d7ae869", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", 0 },
+		{ NULL, NULL, 0 }
+	};
+
+	cl_git_pass(git_oid_fromstr(&oid, can_create_a_note_from_commit[0].object_oid));
+
+	cl_git_pass(git_note_commit_create(&notes_commit_out, NULL, _repo, NULL, _sig, _sig, &oid, "I decorate 4a20\n", 1));
+
+	/* create_from_commit will not update any ref,
+	 * so we must manually create the ref, that points to the commit */
+	cl_git_pass(git_reference_create(&ref, _repo, "refs/notes/i-can-see-dead-notes", &notes_commit_out, 0, NULL));
+
+	cl_git_pass(git_note_foreach(_repo, "refs/notes/i-can-see-dead-notes", note_list_create_cb, &can_create_a_note_from_commit));
+
+	assert_notes_seen(can_create_a_note_from_commit, 1);
+
+	git_reference_free(ref);
+}
+
+
+/* Test that we can create a note from a commit, given an existing commit */
+void test_notes_notes__can_create_a_note_from_commit_given_an_existing_commit(void)
+{
+	git_oid oid;
+	git_oid notes_commit_out;
+	git_commit *existing_notes_commit = NULL;
+	git_reference *ref;
+	static struct note_create_payload can_create_a_note_from_commit_given_an_existing_commit[] = {
+		{ "1c9b1bc36730582a42d56eeee0dc58673d7ae869", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", 0 },
+		{ "1aaf94147c21f981e0a20bf57b89137c5a6aae52", "9fd738e8f7967c078dceed8190330fc8648ee56a", 0 },
+		{ NULL, NULL, 0 }
+	};
+
+	cl_git_pass(git_oid_fromstr(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045"));
+
+	cl_git_pass(git_note_commit_create(&notes_commit_out, NULL, _repo, NULL, _sig, _sig, &oid, "I decorate 4a20\n", 0));
+
+	cl_git_pass(git_oid_fromstr(&oid, "9fd738e8f7967c078dceed8190330fc8648ee56a"));
+
+	git_commit_lookup(&existing_notes_commit, _repo, &notes_commit_out);
+
+	cl_assert(existing_notes_commit);
+
+	cl_git_pass(git_note_commit_create(&notes_commit_out, NULL, _repo, existing_notes_commit, _sig, _sig, &oid, "I decorate 9fd7\n", 0));
+
+	/* create_from_commit will not update any ref,
+	 * so we must manually create the ref, that points to the commit */
+	cl_git_pass(git_reference_create(&ref, _repo, "refs/notes/i-can-see-dead-notes", &notes_commit_out, 0, NULL));
+
+	cl_git_pass(git_note_foreach(_repo, "refs/notes/i-can-see-dead-notes", note_list_create_cb, &can_create_a_note_from_commit_given_an_existing_commit));
+
+	assert_notes_seen(can_create_a_note_from_commit_given_an_existing_commit, 2);
+
+	git_commit_free(existing_notes_commit);
+	git_reference_free(ref);
+}
+
 /*
  * $ git notes --ref i-can-see-dead-notes add -m "I decorate a65f" a65fedf39aefe402d3bb6e24df4d4f5fe4547750
  * $ git notes --ref i-can-see-dead-notes add -m "I decorate c478" c47800c7266a2be04c571c04d5a6614691ea99bd
@@ -253,6 +375,71 @@ static char *messages[] = {
 
 #define MESSAGES_COUNT (sizeof(messages)/sizeof(messages[0])) - 1
 
+/* Test that we can read a note */
+void test_notes_notes__can_read_a_note(void)
+{
+	git_oid note_oid, target_oid;
+	git_note *note;
+
+	create_note(&note_oid, "refs/notes/i-can-see-dead-notes", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", "I decorate 4a20\n");
+
+	cl_git_pass(git_oid_fromstr(&target_oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045"));
+
+	cl_git_pass(git_note_read(&note, _repo, "refs/notes/i-can-see-dead-notes", &target_oid));
+
+	cl_assert_equal_s(git_note_message(note), "I decorate 4a20\n");
+
+	git_note_free(note);
+}
+
+/* Test that we can read a note with from commit api */
+void test_notes_notes__can_read_a_note_from_a_commit(void)
+{
+	git_oid oid, notes_commit_oid;
+	git_commit *notes_commit;
+	git_note *note;
+
+	cl_git_pass(git_oid_fromstr(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045"));
+
+	cl_git_pass(git_note_commit_create(&notes_commit_oid, NULL, _repo, NULL, _sig, _sig, &oid, "I decorate 4a20\n", 1));
+
+	git_commit_lookup(&notes_commit, _repo, &notes_commit_oid);
+
+	cl_assert(notes_commit);
+
+	cl_git_pass(git_note_commit_read(&note, _repo, notes_commit, &oid));
+
+	cl_assert_equal_s(git_note_message(note), "I decorate 4a20\n");
+
+	git_commit_free(notes_commit);
+	git_note_free(note);
+}
+
+/* Test that we can read a commit with no note fails */
+void test_notes_notes__attempt_to_read_a_note_from_a_commit_with_no_note_fails(void)
+{
+	git_oid oid, notes_commit_oid;
+	git_commit *notes_commit;
+	git_note *note;
+
+	cl_git_pass(git_oid_fromstr(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045"));
+
+	cl_git_pass(git_note_commit_create(&notes_commit_oid, NULL, _repo, NULL, _sig, _sig, &oid, "I decorate 4a20\n", 1));
+
+	git_commit_lookup(&notes_commit, _repo, &notes_commit_oid);
+
+	cl_git_pass(git_note_commit_remove(&notes_commit_oid, _repo, notes_commit, _sig, _sig, &oid));
+	git_commit_free(notes_commit);
+
+	git_commit_lookup(&notes_commit, _repo, &notes_commit_oid);
+
+	cl_assert(notes_commit);
+
+	cl_git_fail_with(GIT_ENOTFOUND, git_note_commit_read(&note, _repo, notes_commit, &oid));
+
+	git_commit_free(notes_commit);
+}
+
 /*
  * $ git ls-tree refs/notes/fanout
  * 040000 tree 4b22b35d44b5a4f589edf3dc89196399771796ea    84
@@ -298,6 +485,50 @@ void test_notes_notes__can_read_a_note_in_an_existing_fanout(void)
 	git_note_free(note);
 }
 
+/* Can remove a note */
+void test_notes_notes__can_remove_a_note(void)
+{
+	git_oid note_oid, target_oid;
+	git_note *note;
+
+	create_note(&note_oid, "refs/notes/i-can-see-dead-notes", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", "I decorate 4a20\n");
+
+	cl_git_pass(git_oid_fromstr(&target_oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045"));
+	cl_git_pass(git_note_remove(_repo, "refs/notes/i-can-see-dead-notes", _sig, _sig, &target_oid));
+
+	cl_git_fail(git_note_read(&note, _repo, "refs/notes/i-can-see-dead-notes", &target_oid));
+}
+
+/* Can remove a note from a commit */
+void test_notes_notes__can_remove_a_note_from_commit(void)
+{
+	git_oid oid, notes_commit_oid;
+	git_note *note = NULL;
+	git_commit *existing_notes_commit;
+	git_reference *ref;
+
+	cl_git_pass(git_oid_fromstr(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045"));
+
+	cl_git_pass(git_note_commit_create(&notes_commit_oid, NULL, _repo, NULL, _sig, _sig, &oid, "I decorate 4a20\n", 0));
+
+	git_commit_lookup(&existing_notes_commit, _repo, &notes_commit_oid);
+
+	cl_assert(existing_notes_commit);
+
+	cl_git_pass(git_note_commit_remove(&notes_commit_oid, _repo, existing_notes_commit, _sig, _sig, &oid));
+
+	/* remove_from_commit will not update any ref,
+	 * so we must manually create the ref, that points to the commit */
+	cl_git_pass(git_reference_create(&ref, _repo, "refs/notes/i-can-see-dead-notes", &notes_commit_oid, 0, NULL));
+
+	cl_git_fail(git_note_read(&note, _repo, "refs/notes/i-can-see-dead-notes", &oid));
+
+	git_commit_free(existing_notes_commit);
+	git_reference_free(ref);
+	git_note_free(note);
+}
+
+
 void test_notes_notes__can_remove_a_note_in_an_existing_fanout(void)
 {
 	git_oid target_oid;
@@ -388,3 +619,46 @@ void test_notes_notes__empty_iterate(void)
 
 	cl_git_fail(git_note_iterator_new(&iter, _repo, "refs/notes/commits"));
 }
+
+void test_notes_notes__iterate_from_commit(void)
+{
+	git_note_iterator *iter;
+	git_note *note;
+	git_oid note_id, annotated_id;
+	git_oid oids[2];
+	git_oid notes_commit_oids[2];
+	git_commit *notes_commits[2];
+	const char* note_message[] = {
+		"I decorate a65f\n",
+		"I decorate c478\n"
+	};
+	int i, err;
+
+	cl_git_pass(git_oid_fromstr(&(oids[0]), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"));
+	cl_git_pass(git_oid_fromstr(&(oids[1]), "c47800c7266a2be04c571c04d5a6614691ea99bd"));
+
+	cl_git_pass(git_note_commit_create(&notes_commit_oids[0], NULL, _repo, NULL, _sig, _sig, &(oids[0]), note_message[0], 0));
+
+	git_commit_lookup(&notes_commits[0], _repo, &notes_commit_oids[0]);
+	cl_assert(notes_commits[0]);
+
+	cl_git_pass(git_note_commit_create(&notes_commit_oids[1], NULL, _repo, notes_commits[0], _sig, _sig, &(oids[1]), note_message[1], 0));
+
+	git_commit_lookup(&notes_commits[1], _repo, &notes_commit_oids[1]);
+	cl_assert(notes_commits[1]);
+
+	cl_git_pass(git_note_commit_iterator_new(&iter, notes_commits[1]));
+
+	for (i = 0; (err = git_note_next(&note_id, &annotated_id, iter)) >= 0; ++i) {
+		cl_git_pass(git_note_commit_read(&note, _repo, notes_commits[1], &annotated_id));
+		cl_assert_equal_s(git_note_message(note), note_message[i]);
+		git_note_free(note);
+	}
+
+	cl_assert_equal_i(GIT_ITEROVER, err);
+	cl_assert_equal_i(2, i);
+
+	git_note_iterator_free(iter);
+	git_commit_free(notes_commits[0]);
+	git_commit_free(notes_commits[1]);
+}